1.类和对象的关系
类是抽象的,对象是具体的,类是具有相同属性和方法的对象的集合,对象是类的一个实例,是一个具体的实体

创建类和对象
创建一个类(属性和方法)
通过这个类创建对象 (构造方法)
使用对象名调用属性和方法, 对象名.属性;  对象名.方法名();

方法的定义

方法定义类的某种行为或功能,是功能的实现

2.方法的五要素

(1)访问权限修饰符
public    protected    默认修饰符    private
这几个修饰符的区别:
public修饰的内容在任何地方都可以访问;private修饰的内容只有本类可以访问;默认修饰符修饰的内容可以在同一个包下访问;protected修饰的内容可以在同一个包下访问,并且所有的子类也可以访问(不管是不是同包)

(2)返回值类型:
如果方法有返回值,方法中必须使用关键字return返回某个值,返回值类型为该值的类型,且返回值只能有一个
return作用:结束方法,返回结果
注意:当调用有返回值的方法时,需要定义一个变量接收.如果方法没有返回值, 返回值类型为void;构造方法没有返回值类型

(3)方法名:
方法名的定义遵循驼峰原则:首字母小写,而后每个单词首字母大写

(4)参数列表
方法执行时的条件,没有内容则不需要条件
编写参数的语法和属性一致,数据类型 参数名
方法声明时的参数列表内是形式参数,也称为形参,就是一个占位符,不是具体值.当用户调用此方法时,需要传递符合形参的实际参数,也称为实参.如果定义的方法有多个形参,之间用逗号隔开

(5)方法体
{}中的内容,是此方法具体功能的实现

3.方法的调用

调用类的普通方法,需要创建该类的对象,对象名.方法名();
方法间可以相互调用,不需要知道方法的具体实现

4.构造方法    --创建对象,初始化对象
特点:
(1)修饰符必须是public
(2)没有返回值类型
(3)方法名必须和类名一致
(4)只有创建对象时才会调用,不能用类名.方法名()的方式调用,但是可以用this()的形式在其他构造方法中调用它,此时this()必须在代码块第一行
(5)类中没有显示的构造方法,系统会给出默认的无参构造方法,当类中有了有参构造方法,系统不会自动生成默认无参构造方法,若需要则重新定义即可

构造方法与普通方法的区别:
(1)构造方法的修饰符是public,一般方法根据实际情况选择
(2)构造方法没有返回值类型,一般方法要么是void要么有具体返回值类型
(3)构造方法名和类名相同,普通方法名见名思意,遵循驼峰原则
(4)构造方法体是对象的初始化代码,普通方法是功能的实现
(5)构造方法用new this super调用;普通方法使用对象调用

5.方法重载:overload
方法重载的判断标准:同类同名不同参(参数列表:个数不同,类型不同,类型顺序不同)

6.this关键字用法
调用属性:this.health = 100;
调用方法:this.print();
调用构造方法:this();this("小黑",100,90);这种方法调用必须位于构造方法第一行

7.成员变量与局部变量的区别
(1)定义位置不同:
成员变量属于类(其实就是属性)
局部变量属于方法
(2)作用域不同:
类中的每个方法都可以使用成员变量
局部变量只能在声明它的方法中使用
(3)初始值不同:
成员变量有默认初始值,在加载类的时候就会给成员变量赋值(默认值);局部变量没有初始值,必须初始化之后才可以使用
(4)生命周期不同:
成员变量随着对象的创建而创建,随着对象的消失而消失
局部变量随着方法的调用而创建
(5)优先级不同:
当局部变量和成员变量同名时,优先使用局部变量的值

8.封装

概念:java三大特性之一,将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问

实现封装的步骤:
(1)私有化属性,使用private修饰
(2)创建公共的gettersetter方法
(3)在setter方法中添加控制语句

封装的好处:
(1)隐藏了实现的细节,提高安全性
(2)符合java的"高内聚,低耦合"思想
(3)提高软件的独立性和可重用性

9.包
作用:文档分门别类,易于查找和管理;
解决文件同名冲突的问题;
有助于实施访问权限管理;
package需要放在java源码的第一条语句,有且只有一条;
包名有小写字母组成,不能以圆点开头或结尾
包名之前最好加上唯一前缀,通常是组织倒置的域名
如果需要使用其他包下面的类,可以使用import关键字导入
import 包名.类名;放在package下面,可以有多条导入语句

10.static修饰符
可以用来修饰属性,修饰方法,修饰代码块
静态变量,静态方法,静态代码块

静态资源不需要依赖于对象,可以直接通过类名.静态资源
静态资源在内存中只有一个,不同的对象操作的都是同一个内容
注意:在类加载的时候,先加载静态资源,再加载非静态资源

每创建一个对象都会执行一次构造方法,但是静态代码块只会在第一次创建对象前执行一次
静态变量特点:
被static修饰;在内存中只有一个,加载类的时候创建,被所有方法和对象共享;其他类中直接通过类名访问
静态方法特点:
静态方法不能使用this和super;
不能直接访问所属类的实例变量和实例方法;
(面试题:静态方法能不能访问非静态资源?通过对象来访问;静态方法能不能直接访问非静态资源?不可以)
可以通过类名.方法名()访问;
规定:静态只能调用静态,非静态只能调用非静态;

11.静态变量和实例变量的区别:
静态变量:
被static修饰;在内存中只有一个拷贝;类内部可在任何方法内直接访问静态变量;其他类中使用类名.静态资源来访问;在创建对象之前会被加载;
实例变量:
没有被static修饰;每创建一个实例都会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响;必须要通过对象调用;随着对象的创建而被创建;
注意:在静态资源内部不能直接调用非静态资源(属性和方法)
规定:静态调用静态,非静态调用非静态

12.继承

java中继承使用extends关键字
类:具有共同属性和行为的一组对象,它是创建对象的模板或蓝图
子类:子类是继承其他类的类,它也称为派生类,扩展类或子类
超类/父类:超类是子类继承功能的类,也称为基类或父类,通用的方法和属性;
可重用性;
Java中类只支持单继承,一个类只能有一个直接父类,但是父类可以是其他类的子类

子类中如何调用父类的方法?
可以使用super关键字对弗雷德方法进行调用,super.方法名/属性;
super的用法有哪些?
调用父类的方法/属性;调用父类的构造方法,必须位于第一行;子类在创建对象,调用自己的构造方法时,会先调用父类的构造方法

子类到底继承了父类的哪些内容?
公共的属性和方法;
被protected修饰的属性和方法;
当父类和子类在同一个包下的话,子类还继承了父类的默认修饰符修饰的内容

子类不能继承父类的内容:
private修饰的内容;
子类和父类不在同一个包下时,不能继承默认访问权限的成员;
不能继承父类的构造方法

继承什么时候使用?
符合is-a 关系的设计时,可以考虑使用继承
如:小狗是一个宠物,小猫是一个宠物,则可以设计宠物类作为小狗/小猫的父类

package com.sky.oop01;public class GenshinRole {String roleName;//角色名int roleAge;//年龄String roleProperty;//属性String country;//所属国家int atk;//攻击力int bloodVolume;//血量public GenshinRole(String _roleName,int _roleAge,String _roleProperty,String _country,int _atk,int _bloodVolume){this.roleName = _roleName;this.roleAge = _roleAge;this.roleProperty = _roleProperty;this.country = _country;this.atk = _atk;this.bloodVolume = _bloodVolume;}public void introduceOneself(){System.out.println("我是"+roleName+","+roleAge+"岁了,来自于"+country+","+roleProperty+"属性"+",我一击伤害是"+atk+",我血量是"+bloodVolume);}public void successAttakZhongli(int _atk){if(_atk >= 50000){System.out.println("我能一击破钟离盾");}else{System.out.println("我不能一击破钟离盾");}}public void chenshouLeishenyidao(int _bloodVolume){if(_bloodVolume > 1000000){System.out.println("我能正面接雷神一刀");}else{System.out.println("我不能正面接雷神一刀");}}}

package com.sky.oop01;public class Students {/** 创建类* 通过类创建对象* 使用对象调用属性或者方法* *///属性//数据类型 属性名;int studentNo;//学号String name;//名字int age;//年龄String stuClass;//班级String hobby;//爱好}package com.sky.oop01;public class Teachers {String name;String majorField;//专业方向String course;//教授课程int teachingYear;//教龄}package com.sky.oop01;import java.util.Scanner;public class Users {String userName;int pwd;public void updatePassword(Users p){//接收用户的输入,对比用户名密码,若正确则可以修改密码Scanner sc = new Scanner(System.in);System.out.println("请输入用户名:");String _username = sc.next();System.out.println("请输入密码:");int _pwd = sc.nextInt();boolean flag = true;//判断字符串是否=相同用equals方法if(p.userName.equals(_username)){if(p.pwd == _pwd){System.out.println("请输入新密码");p.pwd = sc.nextInt();flag = false;}else{System.out.println("用户名或密码不匹配,您没有权限更新管理员信息");}}else{System.out.println("用户名或密码不匹配,您没有权限更新管理员信息");}if(!flag){System.out.println("您的账户信息更新为"+p.userName+"\t"+p.pwd);}}}

package com.sky.oop01;public class Demo {public static void main(String[] args) {//根据类创建对象//类名 对象名 = new 类名();Students zhangsan = new Students();zhangsan.name = "张三";zhangsan.age = 12;zhangsan.stuClass = "3年2班";zhangsan.hobby = "篮球";zhangsan.studentNo = 25;System.out.println(zhangsan.name);System.out.println(zhangsan.age);System.out.println(zhangsan.stuClass);System.out.println(zhangsan.hobby);System.out.println(zhangsan.studentNo);Teachers Lisi = new Teachers();Lisi.name = "李四";Lisi.majorField = "计算机";Lisi.course = "Java大数据开发";Lisi.teachingYear = 5;System.out.println(Lisi.name);System.out.println(Lisi.majorField);System.out.println(Lisi.course);System.out.println(Lisi.teachingYear);//使用对象//对象名.属性  对象名.方法名//通过对象名属性进行赋值,同时可以适用对象名调用里面的方法//属性是什么类型,就必须要赋什么类型的值GenshinRole Hutao = new GenshinRole("胡桃",15,"火","璃月",60000,32000);Hutao.introduceOneself();Hutao.successAttakZhongli(Hutao.atk);Hutao.chenshouLeishenyidao(Hutao.bloodVolume);//创建对象p1并为其赋值Users p1 = new Users();p1.userName = "admin1";p1.pwd = 111111;p1.updatePassword(p1);}
}

package com.sky.oop01;public class Sightseer {//属性public String name;public int age;public int price;//构造方法重载public Sightseer(String _name,int _age,int _price){this.name = _name;this.age = _age;this.price = _price;}public Sightseer(String _name,int _age){this.name = _name;this.age = _age;}//选择价格public int selectPrice(int age){if(age<18||age>=60){this.price = 10;}else if(age<60&&age>=18){this.price = 20;}else{System.out.println("年龄输入错误 ");return -1;}return price;}//打印public void printPrice(){System.out.println(this.name+"的年龄为:"+this.age+",门票价格为:"+this.selectPrice(this.age)+"元");}
}

package com.sky.oop01;import java.util.ArrayList;
import java.util.Scanner;public class SightseerTest {public static void main(String[] args) {//循环创建一个游客对象,输出应该多少票价Scanner sc = new Scanner(System.in);while(true){System.out.print("请输入姓名:");String _name = sc.next();if(_name.equals("n")){System.out.println("程序结束");break;}System.out.print("请输入年龄:");int _age = sc.nextInt();Sightseer person = new Sightseer(_name,_age);person.printPrice();}}
}

package com.sky.oop2;import java.util.Arrays;public class Student {//类型 属性名;int studentNo;String name;int age;String address;//构造方法--作用,创建和初始化对象/** 修饰符必须是public ,没有返回值类型,方法名必须和类名保持一致* * 注意:* 1.构造方法在创建对象的时候执行,不能像普通方法一样被调用* 2.如果类当中没有显示的构造方法的话,系统会帮你创建一个无参的构造方法* 只要类中出现了构造方法,系统则不会帮你创建构造方法* 3.关键字:this,当前对象,谁来调用这个方法,this指的就是谁*/public Student(){}//方法//当前类的属性在当前类的方法中是可以直接使用的public void show(){System.out.println("我叫:"+name+",今年:"+age+",家住:"+address);}/*方法:功能* 方法的五要素:* 访问权限修饰符(public,pravite,protect)	* 返回值类型	void	* 方法名		eat* 参数列表	()方法执行时要不要条件,没有内容则不要条件,编写参数的语法与属性一致 ,数据类型 参数名(形式参数),调用时需要传递实参* 形参的值是由调用者在传递时决定的	* 方法体		{}具体功能的实现步骤	*/public void eat(){System.out.println("我喜欢吃老乡鸡");}public String buySmoke(int money){String yanming = "";System.out.println("我骑车去买烟,老师给了:"+money+"元");if(money<=10&&money>0){yanming = "红塔山";}else if(money <=30){yanming = "玉溪";}else if(money>30){yanming = "中华";}else{System.out.println("金钱错误");}return yanming;}/** 向指定数组中,增加学员姓名,成功之后返回true* 可以再数组中查看所有学生姓名*/public String[] add(String name,String[] names){/** 1.判断数组是否满了* 		1.1获取数组的最后一位,如果有值,说明数组满了,对数组进行扩容,将值存在最后一个位置;如果没有值,* 		说明数组还有空位,找到第一个为空的下标,将name存储到该位置* */String last = names[names.length-1];int index = -1;if(last == null){//没有满for (int i = 0; i < names.length; i++) {if(names[i] == null){index = i;break;}}}else{//满了names = Arrays.copyOf(names, names.length+1);index = names.length-1;}names[index] = name;return names;}/** 判断数组中是否有输入的姓名* 开始,结束,找谁,要返回值*/public int searchName(String[] names,String name,int s,int e){//判断输入的参数是否符合条件/** 开始和结束必须大于0,同时都必须要小于数组长度* s<e*/int flag = 0;if(s >= 0 && e > 0 && s < e && e <= names.length-1){//进行查找for (int i = s; i <= e; i++) {if(names[i].equals(name)){//equals用于字符串和对象的比较,比较2个是不是相同,如果相同返回true,不同返回falseflag = 1;break;}}}else{System.out.println("输入区间不合理");}return flag;}}

package com.sky.oop2;public class Computer {//实现简易计算器/** 分别实现两个整数,三个浮点数的加法运算* 创建一个类:computer* 声明两个方法,1个接受2个整数类型参数* 1个接受3个小数类型的参数* 实现他们相加的功能,返回结果* */public int sum(int a,int b){return a+b;}public double sum(double a,double b,double c){return a+b+c;}
}

 

package com.sky.oop2;import java.util.Arrays;public class Demo {public static void main(String[] args) {/*Student s = new Student();s.name = "小美 ";s.age = 26;s.address = "东莞市";s.show();//一般调用有返回值的方法会定义一个变量来接收结果String str = s.buySmoke(50);System.out.println(str);Computer cpt = new Computer();System.out.println(cpt.sum(1, 2));System.out.println(cpt.sum(1.1, 2.2, 3.3));*/Student s = new Student();String[] names = {"xiaomei","xiaoli","xiaojun","xiaofang"};
//		String[] names1 = new String[10];
//		names1[0] = "xiaolen";
//		names = s.add("xiaowen1", names);
//		System.out.println(Arrays.toString(names));
//		System.out.println(Arrays.toString(s.add("xiaowen", names1)));String name = "xiaoli";int i = s.searchName(names, name, 0, 2);if(i==1){System.out.println("在数组:"+Arrays.toString(names)+"中找到了:"+name);}else{System.out.println("没有找到");}}
}

package com.sky.oop3;public class Computer {//方法重载:/** 在同一个类中存在多个方法,方法名相同,参数列表不同(参数个数不同,参数类型不同,顺序不同)* 判断方法是否构成重载*/
//	public int sum(int num1,String num2){
//		return 1;
//	}
//	public int sum(String num1,int num2){
//		return 2;
//	}public int sum(int num1,int num2){return num1+num2;}public double sum(double num1,double num2,double num3){return num1+num2+num3;}}

package com.sky.oop3;public class Dog {// 成员变量和属性是有默认值的String name;String sex;int health;int lovely;/** 如果在类中没有显示的编写构造方法的话,系统会帮你添加一个无参的构造方法* 如果类中存在显示的构造方法了,则系统不会添加*/public Dog(){System.out.println("Dog()");}public Dog(String name, String sex){this.name = name;this.sex = sex;System.out.println("Dog(String name, String sex)");}public Dog(String name, String sex, int health, int lovely) {//super();//this 表示当前对象/*this 主要功能:* 1.调用属性,如有参构造中对属性赋值* 2.调用方法,this.方法名* 3.调用构造方法 this() -  调用无参构造方法* 调用构造方法时必须要位于第一行*///this(name,sex);this.name = name;this.sex = sex;this.health = health;this.lovely = lovely;//System.out.println("Dog(String name, String sex, int health, int lovely)");}public void show(){System.out.println("我叫"+name+",性别是"+sex+",我的健康值是"+health+",我的活跃度是"+lovely);}/** 基本数据类型作为参数时,传递的是具体的值* 对象作为参数在传递的时候,传递的是地址*/
}

package com.sky.oop3;public class Demo {public static void main(String[] args) {//构造方法:创建对象并且初始化(属性赋值过程)Dog dog = new Dog();dog.name = "旺财";dog.sex = "雌";dog.health = 90;dog.lovely = 80;Dog d = new Dog("来福","雄",80,100);Computer cpt = new Computer();System.out.println(cpt.sum(1, 2));System.out.println(cpt.sum(1.1, 2.2, 3.3));}
}

package duoduo;public class Student {/** static	静态* 可以用来修饰属性,修饰方法,修饰代码块* static{* * }* 被static修饰的变量	-静态变量* 被static修饰的方法	-静态方法* 被static修饰的代码块	-静态代码块* 静态资源不需要依赖于对象,通过类名.静态资源可以直接访问* 静态资源(变量和方法)在内存中只有一个,不同的对象操作的都是同一个内容* * 注意:在类加载时,先加载静态资源,然后再加载非静态资源* 在静态方法中能否调用非静态方法?* 可以创建对象调用非静态方法,但是不能直接调用非静态方法* * 可以根据是不是被static修饰的属性,分为静态变量(不依赖对象,直接使用类名来调用),实例变量(必须要对象才能调用的)* */private String name;private int age;private String sex;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}}package duoduo;public class Computer {//属性--成员变量int num;String brand;/** 1.定义位置不同:成员变量在类中定义,局部变量在方法中定义* 2.作用域不同:成员变量属于类,在所有方法中都可以使用,局部变量只能在定义的方法中使用* 3.初始值不同:成员变量有默认值* 4.优先级不同:如果成员变量和局部变量同名,局部变量的优先级较高* 5.生命周期不同:成员变量属于类,随着对象的创建而创建,随对象的消失而消失--垃圾回收期;* 			       局部变量属于方法,随着方法的调用而创建.* *///方法,行为,成员方法public int sum(int num1, int num2){return num1+num2;}public void show(){System.out.println("品牌:"+brand+",价格:"+num);}
}package duoduo;public class Penguin {private int health;private int lovely;private String name;private String sex;public int getHealth() {return health;}public void setHealth(int health) {if(health < 0 || health > 100){System.out.println("默认值60");this.health = 60;}else{this.health = health;}}public int getLovely() {return lovely;}public void setLovely(int lovely) {if(lovely < 0 || lovely > 100){System.out.println("默认值60");this.lovely = 60;}else{this.lovely = lovely;}}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public Penguin(int health, int lovely, String name, String sex) {//super();this.health = health;this.lovely = lovely;this.name = name;this.sex = sex;}public Penguin() {}public void show(){System.out.println("姓名:"+name+",性别"+sex+",健康度"+health+",亲密度"+lovely);}
}package duoduo;public class Dog {//1.所有的属性全部进行私有化//2.为所有的属性提供getter setter方法private String name;private int age;private int health;private int lovaly;//为属性赋值public void setName(String name){this.name = name;}public String getName(){return name;}public void setAge(int age){if(age < 0 || age > 30){System.out.println("赋值不合理,系统给了默认值: 5");this.age = 5;}else{this.age = age;}}public int getAge(){return age;}public void setHealth(int health){if(health < 0 || health > 100){System.out.println("赋值不合理,系统给了默认值: 60");this.health = 60;}this.health = health;}public int getHealth(){return health;}public void setLovaly(int lovaly){if(lovaly < 0 || lovaly > 100){System.out.println("赋值不合理,默认值: 80");this.lovaly = 80;}this.lovaly = lovaly;}public int getLovaly(){return lovaly;}
}package duoduo;import java.util.Scanner;public class Demo {public static void main(String[] args) {
//		Computer c = new Computer();
//		c.brand = "外星人";
//		c.num = 30000;
//		c.show();/** 代码是有缺陷的,没有对用户输入的内容做校验* 不能随意给属性赋值* 通过封装:* 1.将属性隐藏起来,在属性前面加上private关键字,隐藏属性,私有化属性* 2.我们提供操作属性的方法,调用这个方法,也可以实现对这个属性进行赋值* 		setHealth();	getHealth();* 不是不让取值,不能直接取值 了,提供了get方法,这个方法可以将需要的属性给你* 3.在赋值的时候,对赋值的内容进行审核,如果合理的话,则进行赋值,不合理则给你默认值* * 私有化属性,只能在当前类中使用* 提供公共的getter setter方法,位属性进行赋值取值* 在setter方法中进行值得审核* * 访问权限修饰符* public	公开的,在任何地方都可以访问* 默认修饰符	只能在当前包下访问,其他包下的类是不能访问的* private	私有的,只能在当前类中访问* protected	访问权限和默认修饰符一样,区别在于它修饰的内容在子类中也可以访问 * *///		Dog d = new Dog();
//		d.setHealth(-80);
//		System.out.println(d.getHealth());Scanner sc = new Scanner(System.in);Penguin pe = new Penguin();System.out.println("欢迎来到宠物店!");System.out.print("请输入要领养的宠物名字:");String name = sc.next();pe.setName(name);System.out.print("请选择要领养的宠物类型:(1.狗狗	2.企鹅)");int select1 = sc.nextInt();String zhonglei = "";if(select1 == 1){zhonglei = "狗狗";}else{zhonglei = "企鹅";}System.out.print("请选择企鹅性别: (1.Q仔	2.Q妹)");int select2 = sc.nextInt();String xingbie = "";if(select2 == 1){xingbie = "Q仔";}else{xingbie = "Q妹";}pe.setSex(xingbie);System.out.print("请输入企鹅健康值:(1~100)");int health = sc.nextInt();pe.setHealth(health);System.out.println("宠物自白:");System.out.println("我的名字叫"+pe.getName()+",健康值是"+pe.getHealth()+",和主人的亲密度是"+pe.getLovely()+"我的性别是"+pe.getSex());pe.show();}
}

package com.sky.oop4;public class Car {private int site = 4;Car(){System.out.println("载客量"+site+"人");}public void setSite(int site){this.site = site;}void print(){System.out.println("载客量是"+site+"人");}
}package com.sky.oop4;public class Bus extends Car {Bus(int site){super();setSite(site);}
}//结果是:输出两句话,载客量4人  载客量是20人package com.sky.oop4;//继承
//Pet类  --父类,超类
//Cat类  --子类
//可以调用父类的属性和方法
//在java中只能支持单继承,
public class Cat extends Pet {public Cat(String name, int age, int health, int lovely) {
//		this.name = name;
//		this.age = age;
//		this.health = health;
//		this.lovely = lovely;super(name,age,health,lovely);System.out.println("Cat(String name, int age, int health, int lovely)");}public Cat() {super();//调用父类的构造方法,并且必须要第一行System.out.println("Cat()");}	
}package com.sky.oop4;public class Dog extends Pet {private String sex;public Dog(String name, int age, String sex, int health, int lovely) {super(name,age,health,lovely);
//		this.name = name;
//		this.age = age;this.sex = sex;
//		this.health = health;
//		this.lovely = lovely;System.out.println("Dog(String name, int age, String sex, int health, int lovely)");}public Dog() {System.out.println("Dog()");}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}//当子类和父类有相同的方法时,会调用子类的public void show(){//子类如何调用父类的方法,使用super关键字(只有被继承的才能被调用)/** super.属性和方法* super的用法* 1.调用父类的属性和方法* 2.还可以调用父类的构造方法,并且必须位于第一行* 子类在创建对象,调用自己的构造方法的时候,会先调用父类的构造方法* * 子类到底继承了父类的哪些东西?* 1.公共的属性和方法* 2.被protected修饰的属性和方法* 3.父类和子类在同一个包下,子类还继承了父类的默认修饰符修饰的内容* * 不能继承:* 1.private修饰的* 2.不在同一个包下的默认修饰符修饰的内容* 3.构造方法*/super.show();System.out.println("我的性别是: "+sex);}
}package com.sky.oop4;public class Pet {private String name;private int age;private int health;private int lovely;protected int abc;public Pet() {System.out.println("Pet()");}public Pet(String name, int age, int health, int lovely) {this.name = name;this.age = age;this.health = health;this.lovely = lovely;System.out.println("Pet(String name, int age, int health, int lovely)");}public void show(){System.out.println("我叫:"+name+",今年"+age+"岁,健康值是"+health+",活跃度是"+lovely);}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public int getHealth() {return health;}public void setHealth(int health) {this.health = health;}public int getLovely() {return lovely;}public void setLovely(int lovely) {this.lovely = lovely;}}package com.sky.oop4;public class Demo {public static void main(String[] args) {Cat c = new Cat();c.setName("凯迪");c.setAge(2);c.setHealth(80);c.setLovely(80);c.show();Dog d = new Dog();d.setName("来福");d.setAge(2);d.setHealth(90);d.setLovely(70);d.setSex("雄");d.show();Cat c2 = new Cat("mao2",2,80,40);Dog d2 = new Dog("gou2",2,"雄",80,80);c.show();d.show();c2.show();d2.show();Bus bus = new Bus(20);bus.print();}}

package com.day1021.homework;public class Voter {//计数器static int num = 0;//属性private String name;private int age;//投票方法public void vote(){if(num >= 100){}else{num++;System.out.println(name+"已经投了第"+num+"票");}}public static int getNum() {return num;}public static void setNum(int num) {Voter.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {if(age < 18 || age > 100){System.out.println("年龄不符合,默认值18");this.age = 18;}else{this.age = age;}}//构造方法public Voter() {}public Voter(String name, int age) {//super();this.name = name;this.age = age;}}package com.day1021.homework;public class Demo {public static void main(String[] args) {for (int i = 0; i < 200; i++) {Voter v = new Voter("第"+(i+1)+"人",25);v.vote();}}
}package com.day1021.homework;public class StaticTest {static int num;//0public static void main(String[] args) {num++;//1StaticTest st1 = new StaticTest();st1.num++;//2StaticTest st2 = new StaticTest();st2.num++;//3StaticTest.num++;//4System.out.println(num);//4}
}package com.day1021.homework;public class Dog {private String name = "旺财";private int health;private String love;static int localv;public void play(int n){localv = 5;health = health-n;System.out.println(name+" "+localv+" "+health+" "+love);}public static void main(String[] args){Dog d = new Dog();d.play(5);}
}

package com.sky.oop.practice;public class Cat extends Pet {private String color;public Cat(String name, int age, String sex, String color) {super(name, age, sex);this.color = color;}public Cat() {super();// TODO Auto-generated constructor stub}public void show(){super.show();System.out.println(",颜色是"+color);}public String getColor() {return color;}public void setColor(String color) {this.color = color;}}package com.sky.oop.practice;public class Dog extends Pet {private String brand;//种类public Dog(String name, int age, String sex, String brand) {super(name, age, sex);this.brand = brand;}public Dog() {super();// TODO Auto-generated constructor stub}public void show(){super.show();System.out.println(",种类是"+brand);}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}}package com.sky.oop.practice;public class Pet {protected String name;protected int age;protected String sex;public void show(){System.out.println("我叫"+name+",今年"+age+"岁了,性别是"+sex);}public Pet(String name, int age, String sex) {super();this.name = name;this.age = age;this.sex = sex;}public Pet() {super();// TODO Auto-generated constructor stub}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}
}package com.sky.oop.practice;public class Demo {public static void main(String[] args) {Dog d = new Dog("旺旺",2,"雄","柯基");Cat c = new Cat("咪咪",2,"雌","狸花");d.show();c.show();}
}