javaSE基础

package com.eduask.tzy; public class Student { public String number; public String name; public int age; public String major; public void attendClass(){ System.out.println("上课方法"); } public void exam(){ System.out.println("我在考试"); } }

Eclipse如何导入看源码 Window -----> Preferences -----> java -----> Installed JREs 选中jre7，点击右边的Edit按钮，找到rt.jar文件，选择其中的Source attachment双击 选中External location，再点击External File，找到JDK下面的src压缩文件，然后Ok即可

1、面向对象编程（OOP，Object Oriented Programming） 1）面向对象编程的理解： 万事万物都能看作成一个类，这个类里面，有不同的属性（特征），也有不同的方法（行为，功能）。 如：人类，它的属性有：眼睛，鼻子，耳朵，身高，体重等。 它的方法有：吃饭，睡觉，打篮球，上网，跳舞等。 2）什么是类： class就是类，拥有相同属性和相同方法的一组对象就是类。 如：鱼和鸭子，同样可以看成一类，为什么呢？因为它们有共同的特点，比如可以游泳，可以拿来当食物。 如果我们以游泳来分类，则可以分为动物类。如果我们以可以吃的角度去考虑，我们可以归为食物类。 注意：在我们定义的实体类里面，可以有自定义的类的属性 例子： public class Person { public Header header; //这里的Header就是我们自定义的类型，header可以作为Person的一个属性 } 这里的Header必须要实例化（new），然后给其赋值后，再将header这个实例赋值给person.herder 语法： 修饰符 + class + 类名{ 类的属性 类的方法 } 注意：类名首字母一定要大写。 3）如何实例化对象 关键字：new 语法： 类名 对象名 = new 类名(); 这里的实例化语法是，无参数的构造方法（构造函数）。 4）类的属性 语法：修饰符 数据类型 属性名; 例子：public String name; //名称 如何调用：实例名.属性名 5）方法 什么是方法，所谓的方法就是对象的行为，或者是功能。 方法分为4类： 1）无参数无返回值 语法：修饰符 + void + 方法名(); 2）无参数有返回值 语法：修饰符 + 返回值类型 + 方法名(); 3）有参数无返回值 语法：修饰符 + void + 方法名(参数类型 参数1,参数类型 参数2.....); 4）有参数有返回值 语法：修饰符 + 返回值类型 + 方法名(参数类型 参数1,参数类型 参数2.....); 如何调用方法： 实例名.方法（参数列表）； 以上所有方法，方法名必须要满足驼峰命名法（首字母小写，后面的单词首字母大写） 注意：如果是有返回值的方法，需要通过关键字return来返回具体的值，具体的值必须满足 方法上面定义的返回值的类型。如果想要输出返回值，则需要在输出语句中去调用此方法。 方法如果是没有返回值的则直接进行 对象.方法 调用。 6）构造器（构造方法，构造函数） 构造器分为两类： 1）有参构造 带有参数的构造器，其中的参数，可以是多个的，最好是每个参数都能对应一个属性，如果 多写的参数没有具体的属性与其对应，并不会影响其结果，但是必须要给此参数赋值。 例子： public Person(String name,int age,String address){ this.name = name; this.age = age; } 说明： 1）这里的this代表类实例本身。 2）这里的address参数是没有具体的属性与其对应，但是不影响结果，在调用的时候，这个address 必须被赋值 3）申明构造器时，构造器的名字必须和类名一致 2）无参构造 在java定义实体类的时候，如果我们不写构造器，则java还有一个默认的无参的构造器。 注意：如果说我们没有创建构造器的时候，java有个默认的无参构造。 如果一旦创建了构造器，则默认的构造器就消失了。

包:** 1）标准java库是由一系列包组成，包括java.lang,java.util,java.net等等。 标准Java包就是层次型包结构，就如同硬盘上嵌套的子目录一样，我们可以使用嵌套层次结构来组织包。 2）Java的包是为了更好的规划代码，防止命名冲突和混乱。所以Java出现了打包机制。 3）当把类组织起来放进一个包内之时，也就给包中的成员赋予了相互访问的权限，您就 “拥有”了该包内的程序代码。 4）包访问权限把类聚集在一个包中这一做法提供了意义和理由. 5）不同包下可以有相同名字的类，在包A下可以条用包B下的相同名字的类，使用包全称 例子： com.bao.tzy1.House house = new com.bao.tzy1.House(); 说明：是在tzy2里面调用tzy1里面相同名字的House类，如果我们需要使用另一个包里面全部类， 则可以通过通配符*来调用如:import com.bao.tzy.*;导入包使用关键字import 语法： package com.bao.tzy2; //当前包 import com.bao.tzy1.*; //导入包

package com.eduask.tzy; public class Demo { /* 构造器分为两类： 1）有参构造 带有参数的构造器，其中的参数，可以是多个的，最好是每个参数都能对应一个属性，如果 多写的参数没有具体的属性与其对应，并不会影响其结果，但是必须要给此参数赋值。 例子： public Person(String name,int age,String address){ this.name = name; this.age = age; } 说明： 1）这里的this代表类实例本身。 2）这里的address参数是没有具体的属性与其对应，但是不影响结果，在调用的时候，这个address 必须被赋值 3）申明构造器时，构造器的名字必须和类名一致 2）无参构造 在java定义实体类的时候，如果我们不写构造器，则java还有一个默认的无参的构造器。 注意：如果说我们没有创建构造器的时候，java有个默认的无参构造。 如果一旦创建了构造器，则默认的构造器就消失了。*/ public static void main(String[] args) { Student st = new Student(); st.setName("小名"); st.setAge(15); System.out.println(st.getName()+st.getAge());//年龄太小了 小名25 Student st1 = new Student(); System.out.println(st1.toString());//Student [name=null, age=0] Student st2 = new Student("张三",33); System.out.println(st2.toString());//Student [name=张三, age=33] } } class Student { private String name; private int age; 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<25){ System.out.println("年龄太小了"); this.age =25; }else{ this.age = age; } } public Student(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } public Student() { super(); } }

1、访问修饰符 1）默认的（什么都不写） 只能在相同包的类才能调用，但是子类不能调用父类的属性。 2）public（公共的） 在同一个工程下，任意包下都可以使用。 3）private（私有的） 只能在当前类使用，超过当前类是不能使用的 1）要获取private的属性，则必须要提供公共get set方法，get方法是获取值 set方法是赋值。然后在其他的类里面进行调用get set方法即可访问 到私有的属性 2）get set 方法的快捷键是： Generate Getters and Setters 4）protected（受保护的） 只能在相同包的类才能调用，但是子类可以调用父类的属性。2、非访问修饰符 1）static 1）使用了static静态关键字的方法或属性，则不需要用关键字new来创建对象调用方法和属性，只需要类名.方法名 或者类名.属性 2）局部变量是不能够用static修饰的，一般定义静态变量是在类上方 3）局部变量不能被声明为 static 变量。 4）静态方法不能使用类的非静态变量。 例子： public static void show(){ System.out.println("张三"); } 如果声明了静态方法或变量,值是放在方法区，因为方法区是一个数据共享区;所以不管什么变量访问它,都是同一份. 在静态方法中不能直接访问实例方法和实例变量. 在静态方法中不能使用 this 和 super 关键字. 静态方法不能被 abstract 修饰. 静态的成员变量可以使用类名或者是对象进行访问，非静态成员变量只能使用对象进行访问. 静态函数可以直接访问静态的成员,但是不能够直接访问非静态成员.，非静态函数可以访问静态和非静态成员. 当类被加载时，静态代码块只能被执行一次。类中不同的静态方法代码块按他们在类中出现的顺序被依次执行. 当多个修饰符连用时，修饰符的顺序可以颠倒，不过作为普遍遵守的编码规范，通常把访问控制修饰符放在首位， 其次是 static 或 abstact 修饰符，接着就是其他的修饰符 内部类： 一个类的内部，有另外一个类（可以有多个） 1）如果在内部类里加上了修饰符static，则我们可以直接通过 外层类.内层类 实例名 = new 外层类.内层类(); 例子： Person.Student student = new Person.Student(); 2）如果在类文件上面导入了内部类，例子如：import com.hygj.sta.Person.Student; 我们就可以直接使用内部类建立实例：Student st = new Student(); 3）如果内部类不是static的，那么我们必须先new一个外层的类的实例，然后再外层实例.new 内部类(); 例子： Person person = new Person(); Student student = person.new Student(); 说明：Person是外层类，Student是内部类 2）final（最终的） 1）被final修饰过的实例（对象），是不能够改变它的内存地址的，也就是说不能改变被final修饰过的引用。 2）如果是被final修饰的对象，则对象里面的属性的值是可以更改的，但是如果用final修饰的属性，则是不能 改变它的值的。 3）类中的 Final 方法可以被子类继承，但是不能被子类修改。 4）final 类不能被继承，没有类能够继承 final 类的任何特性。 final 变量必须被显式初始化，并且只能被赋值一次值 final 修饰基本类型变量的时候, 该变量不能重新赋值 final 修饰引用类型变量的时候, 该变量不能重新指向其他对象 final 修饰的方法为最终的方法, 该方法不能被重写 private 类型的方法都默认为是final方法，因而也不能被子类重写 final 修饰的类为最终的类, 不能被继承 3)abstract 修饰符 抽象类不能被实例化. 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象方法. 如果子类没有实现父类中所有的抽象方法，子类也必须定义为抽象类. 抽象类不能被定义为 private、final、和 static 类型. 没有抽象的构造方法. 抽象方法没有方法体,如果一个方法没有方法体,那么该方法必须声明为抽象的方法. 非抽象类继承抽象类的时候,必须要把抽象类中的所有抽象方法实现. 4)注意：以下修饰符一起用是无意义的，会导致编译错误： abstract 与 private abstract 与 final abstract 与 static

this关键字 作用：当成员变量和局部变量或者参数同名的时候用this进行区分。 1）我们在一个构造器里，可以调用其他的构造器（都在同一个类），通过this关键字。 例子： this(); // 这是调用无参构造 2）调用本类的构造函数的this语句必须放在构造函数的第一行，因为要让初始化操作先完成。super关键字 1）super作用：调用父类的方法和属性或者构造器，通过super关键字 2）当子类与父类有同名的属性时，可以通过“super.此属性”，显式的调用父类中声明的属性，若想调用子类的同名的属性“this.此属性” 3）当子类重写父类的方法以后，在子类中若想再显式的调用父类被重写的方法，就需要使用“super.方法”，如果要调用自身的则使用“this.方法” 4） a）super修饰构造器：通过在子类中使用“super（形参）”来显式的调用父类中指定的构造器 b）在构造器内部，“super（形参）”必须声明在首行！ 同this一样 c）在构造器内部，“this（形参）”或“super（形参）”只能出现一个 d）当构造器中，不显示的调用“this（形参）”或者“super（形参）”其中任何一个的时候，调用的则是默认的父类空参的构造器 e）为防止出错，每个类中最好都写上空参的构造器

package com.eduask.tzy; public class Dog { public String brand;//品种 public int age; public String toString(){ return "这是一条"+age+"岁的"+brand; } public static void main(String[]args){ Dog myDog = new Dog(); myDog.age=12; myDog.brand="中华田园犬"; System.out.println(myDog.toString()); //这是一条12岁的中华田园犬 } }

package com.eduask.tzy; public class MethodDemo { public void method1() { System.out.println("返回值类型为空且无参数的方法"); } public String method2() { return "带有具体返回值类型且无参数的方法 "; } public void method3(String name) { System.out.println("返回值类型为空且带参数的方法，参数值为：" + name); } public String method4(String name, int age) { return "带有具体返回值类型且有多个参数的方法，参数的值为: " + name + "," + age; } // 传递基本数据类型 public void operatorData(int age) { age++; System.out.println(age); } // 传递引用数据类型的方法 public void operatorArray(int[] array) { array[2] = 100; System.out.println(array[2]); } public static void main(String[] args) { MethodDemo md = new MethodDemo(); md.method1();// 返回值类型为空且无参数的方法 System.out.println(md.method2());// 带有具体返回值类型且无参数的方法 md.method3("张三");// 返回值类型为空且带参数的方法，参数值为：张三 System.out.println(md.method4("李四", 15));// 带有具体返回值类型且有多个参数的方法，参数的值为: 李四,15 // 测试基本数据类型参数 int age = 10; md.operatorData(age); System.out.println(age);// 10 // 测试引用数据类型参数(注意其实传递的是堆内存地址) int[] array = { 1, 2, 3, 4 }; md.operatorArray(array); System.out.println(array[2]); } }

1、构造器创建的快捷键 1）右键Source，选择Generate Constructor using Fields，再根据需要勾选参数个数 注意：方法里面传的参数和构造器里面的参数是没有任何关系的。 1）我们定义的方法里面的参数是形式参数（形参），可以看作一个变量，它具体的值跟 调用此方法传入的参数有关，传入值是什么，此参数的值就是什么 2、包。 1）不同包下可以有相同名字的类，在包A下可以条用包B下的相同名字的类，使用包全称 例子： com.hygj.j37.House house = new com.hygj.j37.House(); 说明：是在j38里面调用j37里面相同名字的House类，如果我们需要使用另一个包里面全部类， 则可以通过通配符*来调用如:import com.hygj.j37.*;导入包使用关键字import 语法： package com.hygj.j38; //当前包 import com.hygj.j37.*; //导入包 3、访问修饰符 1）默认的（什么都不写） 只能在相同包的类才能调用，但是子类不能调用父类的属性。 2）public（公共的） 在同一个工程下，任意包下都可以使用。 3）private（私有的） 只能在当前类使用，超过当前类是不能使用的 1）要获取private的属性，则必须要提供公共get set方法，get方法是获取值 set方法是赋值。然后在其他的类里面进行调用get set方法即可访问 到私有的属性 2）get set 方法的快捷键是： Generate Getters and Setters 4）protected（受保护的） 只能在相同包的类才能调用，但是子类可以调用父类的属性。 4、非访问修饰符 1）static 1）使用了static静态关键字的方法或属性，则不需要用关键字new来创建对象调用方法和属性，只需要类名.方法名 或者类名.属性 2）局部变量是不能够用static修饰的，一般定义静态变量是在类上方 3）局部变量不能被声明为 static 变量。 4）静态方法不能使用类的非静态变量。 例子： public static void show(){ System.out.println("张三"); } 如果声明了静态方法或变量,值是放在方法区，因为方法区是一个数据共享区;所以不管什么变量访问它,都是同一份. 在静态方法中不能直接访问实例方法和实例变量. 在静态方法中不能使用 this 和 super 关键字. 静态方法不能被 abstract 修饰. 静态的成员变量可以使用类名或者是对象进行访问，非静态成员变量只能使用对象进行访问. 静态函数可以直接访问静态的成员,但是不能够直接访问非静态成员.，非静态函数可以访问静态和非静态成员. 当类被加载时，静态代码块只能被执行一次。类中不同的静态方法代码块按他们在类中出现的顺序被依次执行. 当多个修饰符连用时，修饰符的顺序可以颠倒，不过作为普遍遵守的编码规范，通常把访问控制修饰符放在首位， 其次是 static 或 abstact 修饰符，接着就是其他的修饰符 内部类： 一个类的内部，有另外一个类（可以有多个） 1）如果在内部类里加上了修饰符static，则我们可以直接通过 外层类.内层类 实例名 = new 外层类.内层类(); 例子： Person.Student student = new Person.Student(); 2）如果在类文件上面导入了内部类，例子如：import com.hygj.sta.Person.Student; 我们就可以直接使用内部类建立实例：Student st = new Student(); 3）如果内部类不是static的，那么我们必须先new一个外层的类的实例，然后再外层实例.new 内部类(); 例子： Person person = new Person(); Student student = person.new Student(); 说明：Person是外层类，Student是内部类 2）final（最终的） 1）被final修饰过的实例（对象），是不能够改变它的内存地址的，也就是说不能改变被final修饰过的引用。 2）如果是被final修饰的对象，则对象里面的属性的值是可以更改的，但是如果用final修饰的属性，则是不能 改变它的值的。 3）类中的 Final 方法可以被子类继承，但是不能被子类修改。 4）final 类不能被继承，没有类能够继承 final 类的任何特性。 final 变量必须被显式初始化，并且只能被赋值一次值 final 修饰基本类型变量的时候, 该变量不能重新赋值 final 修饰引用类型变量的时候, 该变量不能重新指向其他对象 final 修饰的方法为最终的方法, 该方法不能被重写 private 类型的方法都默认为是final方法，因而也不能被子类重写 final 修饰的类为最终的类, 不能被继承 3)abstract 修饰符 抽象类不能被实例化. 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象方法. 如果子类没有实现父类中所有的抽象方法，子类也必须定义为抽象类. 抽象类不能被定义为 private、final、和 static 类型. 没有抽象的构造方法. 抽象方法没有方法体,如果一个方法没有方法体,那么该方法必须声明为抽象的方法. 非抽象类继承抽象类的时候,必须要把抽象类中的所有抽象方法实现. 4)注意：以下修饰符一起用是无意义的，会导致编译错误： abstract 与 private abstract 与 final abstract 与 static 修饰符文档

package com.eduask.tzy; public class Demo { public static void main(String[] args) { Student st = new Student(); st.setName("小名"); st.setAge(15); System.out.println(st.getName()+st.getAge()); //年龄太小了 小名25 } } class Student { private String name; private int age; 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<25){ System.out.println("年龄太小了"); this.age =25; }else{ this.age = age; } } }

package com.eduask.tzy; public class StaticDemo { public static void main(String[] args) { Account acc1 = new Account(); // acc1.number1++;//会让下面类变量值改变 // acc1.showNumber1();//2 Account acc2 = new Account(); // acc2.showNumber1();//2 Account.number1++; System.out.println(Account.number1); } } class Account{ public static int number1=1;//静态变量（类变量），它不属于任何对象 private int number2=2; public static int number3; public Account(){ System.out.println("我是无参构造"); } //static语句块：在类加载的时候就会执行，只会执行一次(和多少实例无关)，用来对静态的变量赋值 static{ System.out.println("我是static语句块"); number3 = 100; } public static void showNumber1(){//1、静态方法中不能访问非静态的变量 2、不可以使用this System.out.println(number1); } public void showNumber2(){ System.out.println(number2); } public void showNumber(){//非静态的方法可以访问静态的内容和非静态的属性和方法 showNumber1(); System.out.println("非静态方法访问静态变量"+number1); } }

package com.abc.tzy; public class TestFinal { /* final可以用来修饰变量、方法、类。 final修饰的变量是一个常量。一旦赋值就不能被修改（常量一般都和static关键字配合使用） final修饰类代表此类不能被继承。 final修饰方法代表此方法不能被重写*/ public static void main(String[] args) { X x = new X(); x.show1(); C c = new C(); c.show2(); final X x2 = new X(); // x2 = new X();final用在引用变量上，代表引用变量只能引用一开始所引用的对象，不能改变其指向 x2.number2=5; x2.show2(); } //答案：1 2 5 } /*final*/ class X{//常量类不能被继承 public final int number1 = 1; public int number2 = 2; public void show1(){ // number1++;常量不可以被修改 System.out.println(number1); } //子类不能对父类中的常量方法进行重写 public /*final*/ void show2(){ System.out.println(number2); } } class C extends X{ public void show2(){//Cannot override the final method from X System.out.println(number2); } }

package com.abc.tzy; /* Object类常见方法： String toString() 1-返回该对象的字符串描述性信息。默认输出格式是：类名[字段值，字段值。。。]; 2-只要对象与一个字符串通过“+”连接，系统就会自动调用toString()以 获得对象的字符串描述; 3-常被改写：可以根据用户的需要对其进行重写。 boolean equals() 1-Object类原始功能是实现判断两个对象是否具有相同的引用；要求判断两个对象状态的相等性； 2-在jdk标准库中提供了一些类，比如String,Date,包装类,File类。他们都对equals方法进行了重写。 3-常被改写：可以根据用户的需要对其进行重写. */ public class TestObject { public static void main(String[] args) { Student st = new Student("张三",50); System.out.println(st); System.out.println(st.toString()); Student st1 = new Student("张三",50); System.out.println(st1.equals(st)); } } //不重写 com.abc.tzy.Student@659e0bfd com.abc.tzy.Student@659e0bfd false //重写后姓名张三, 年龄50岁 姓名张三, 年龄50岁 true class Student /*extends Object*/{ //不加也是继承Object private String name; private int age; public Student(String name, int age) { super(); this.name = name; this.age = age; } @Override public String toString() { return "姓名" + name + ", 年龄" + age + "岁"; } /*public boolean equals(Object obj){ //自己跟自己比 if(this==obj){ return true ; } if(obj==null){ return false; } //类型 if(this.getClass()!=obj.getClass()){ return false; } Student stu = (Student)obj; if(this.age!=stu.age){ return false; } if(this.name==null&&stu.name!=null){ return false; }else if(!this.name.equals(stu.name)){ return false; } return true; } */ @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }

package com.eduask.tzy; public class OverloadDemo { public static void main(String[] args) { Printer p = new Printer(1000); System.out.println(p.toString()); Printer p1 = new Printer("戴尔",2000); System.out.println(p1.toString()); p.print("hello"); p.print(11); p.print("hello", 22); p.print( 22,"hello"); } } class Printer{ private String brand = "惠普"; private double price; public Printer(double price){ this.price = price; } public Printer(String brand,double price){ this.brand = brand; this.price = price; } public void print(String content){ System.out.println("字符串："+content); } public void print(int content){ System.out.println("整形："+content); } public void print(String content,int content1){ System.out.println("字符串："+content+"整形"+content1); } @Override public String toString() { return "Printer [brand=" + brand + ", price=" + price + "]"; } // public int print(int content){ // System.out.println("整形："+content); // }这样不是重载，程序无法分辨是哪个方法 public int print(int content,String content1){//重载成功 System.out.println(content+"--"+content1); return 1; } }

package com.abc.tzy; public class TeacherDemo { public static void main(String[] args) { B b = new B(); b.showB(); } } /*A的构造方法 B的构造方法 子类B A 父类B */ class A{ public A(){ System.out.println("A的构造方法"); } public void showA(){ System.out.println("A"); } public void showB(){ System.out.println("父类B"); } } class B extends A{ public B(){ super();//调用父类的构造方法，可以省略，编译时会自动加上。 System.out.println("B的构造方法"); } public void showB(){ System.out.println("子类B"); super.showA(); super.showB(); } }

package com.abc.tzy; public class TeacherDemo1 { public static void main(String[] args) { JavaTeacher jt = new JavaTeacher("张三","666学校"); DBTeacher dt = new DBTeacher("李四", "999学校"); jt.teaching(); dt.teaching(); } } /* 授课前准备 Java老师打开Eclipse 狂写Java代码 授课前准备 DB老师打开Mysql 狂写sql代码 */ class Teacher{ private String name; private String school; //没有无参构造了哦 public Teacher(String name, String school) { super(); this.name = name; this.school = school; } public void teaching(){ System.out.println("授课前准备"); } } class JavaTeacher extends Teacher{ public JavaTeacher(String name, String school) { super(name, school); } public void teaching(){ super.teaching(); System.out.println("Java老师打开Eclipse"); System.out.println("狂写Java代码"); } } class DBTeacher extends Teacher{ public DBTeacher(String name, String school) { super(name, school); } public void teaching(){ super.teaching(); System.out.println("DB老师打开Mysql"); System.out.println("狂写sql代码"); } }

package com.abc.tzy; public class AnimalDemo { public static void main(String[] args) { //父类的引用变量可以引用其子类的对象 Animal an1 = new SDog("旺财"); an1.eat(); Animal an2 = new SCat("招财"); an2.eat(); } } class Animal{ private String name; public Animal(String name){ this.name= name; } //这是一个通用方法，通用的方法实现没有太大的意义，只是告诉其子类去实现它 public void eat(){ System.out.println("能吃东西"); } } class SDog extends Animal{ public SDog(String name) { super(name); } public void eat(){ System.out.println("啃骨头"); } } class SCat extends Animal{ public SCat(String name) { super(name); } public void eat(){ System.out.println("吃鱼"); } }

package com.abc.tzy; /*由子类转型成父类，在继承图上是向上移动的，一般称为向上转型 向上转型是从一个较专用类型向较通用类型转换，所以总是安全的，也就是说，子类是父类的一个超集 向上转型过程中，类接口中唯一开能发生的事情是丢失方法，而不是获取方法 与之相反的操作是向下转型，不安全（可能需要instanceof操作符协助） Lsp(liskov替换原则)：子类型必须能够替换掉它们的基类型 安全的上转型和LSP的实施，充分体现继承的“is-a”关系*/ public class AnimalDemo { public static void main(String[] args) { //父类的引用变量可以引用其子类的对象 Animal an1 =/*(Animal)*/ new SDog("旺财"); //向上转型首先是安全的，可能会导致子类方法的丢失。 //父类的引用变量只能调用父类中有的方法或子类重写父类的方法 an1.eat(); // an1.sleep();//该方法丢失 Animal an2 = new SCat("招财"); an2.eat(); //向下转型是不安全的 //SCat cat =(SCat)an1;//java.lang.ClassCastException //instanceof运算符用来在运行时通过返回一个布尔值来指出对象是否是特定类或者是它的子类的一个实例 if(an1 instanceof SCat){ SCat cat =(SCat)an1; System.out.println("转换成了猫"); cat.eat(); } if(an1 instanceof SDog){ SDog dog =(SDog)an1; System.out.println("转换成了狗"); dog.sleep(); } } } //答案：啃骨头 吃鱼 转换成了狗 狗睡觉 class Animal{ private String name; public Animal(String name){ this.name= name; } //这是一个通用方法，通用的方法实现没有太大的意义，只是告诉其子类去实现它 public void eat(){ System.out.println("能吃东西"); } } class SDog extends Animal{ public SDog(String name) { super(name); } public void eat(){ System.out.println("啃骨头"); } public void sleep(){ System.out.println("狗睡觉"); } } class SCat extends Animal{ public SCat(String name) { super(name); } public void eat(){ System.out.println("吃鱼"); } }

package com.abc.tzy; public class PrinterDemo { public static void main(String[] args) { // ColorPrinter cp = new ColorPrinter("惠普"); // BlackPrinter bp = new BlackPrinter("戴尔"); D3Printer d3 = new D3Printer("王牌"); School sc = new School(); // sc.setPrinter(cp); // sc.setPrinter(bp); sc.setPrinter(d3); sc.print("Hello,java"); } } class Printer{ private String brand; public Printer(String brand){ this.brand=brand; } public String getbrand(){ return brand; } //打印的方法，应该由其子类来具体实现 public void print(String content){ } } //开闭原则：对修改是封闭的，对扩展是开放的。（现在下面代码在加一种打印机就会很麻烦） //多态解决这个问题，父类的引用变量可以引用其子类的对象。 class School{ /*private Printer cp =null; private Printer bp =null;*/ // 这样就写死了没有扩展性，和维护性 private Printer p = null;//我们学校有打印机 //安装彩色打印机 /*public void setPrinter(ColorPrinter cp){ this.cp=cp; } //安装黑白打印机（重载） public void setPrinter(BlackPrinter bp){ this.bp=bp; } public void print(String content){ if(cp!=null){cp.print(content);}// 注意防止java.lang.NullPointerException if(bp!=null){bp.print(content);} }*/ //拿父类的引用变量作为参数，好处就是可以接收任何其子类的对象 public void setPrinter(Printer p){ this.p=p; } public void print(String content){ p.print(content); } } class ColorPrinter extends Printer{ public ColorPrinter(String brand){ super(brand); } //对父类的方法进行重写 public void print(String content){ System.out.println(getbrand()+"彩色打印"+content); } } class BlackPrinter extends Printer{ public BlackPrinter(String brand){ super(brand); } //对父类的方法进行重写 public void print(String content){ System.out.println(getbrand()+"黑白打印"+content); } } class D3Printer extends Printer{ public D3Printer(String brand){ super(brand); } //对父类的方法进行重写 public void print(String content){ System.out.println(getbrand()+"3D打印"+content); } }

package com.abc.tzy; public class PrinterDemo { public static void main(String[] args) { ColorPrinter cp = new ColorPrinter("惠普"); BlackPrinter bp = new BlackPrinter("戴尔"); TTeacher tt = new TTeacher("张三老师", 20); School sc = new School(); sc.setPrinter(bp); sc.print(tt); sc.setPrinter(cp); sc.print(sc); //戴尔黑白打印你好我的名字叫：张三老师，今年:20岁. //惠普彩色打印你好我是王牌有限公司 } } interface IInfo{ public abstract String detail(); } abstract class Printer{ private String brand; public Printer(String brand){ this.brand=brand; } public String getbrand(){ return brand; } //打印的方法，应该由其子类来具体实现 public abstract void print(String content); } //开闭原则：对修改是封闭的，对扩展是开放的。（现在下面代码在加一种打印机就会很麻烦） //多态解决这个问题，父类的引用变量可以引用其子类的对象。 class School implements IInfo{ /*private Printer cp =null; private Printer bp =null;*/ // 这样就写死了没有扩展性，和维护性 private Printer p = null;//我们学校有打印机 //安装彩色打印机 /*public void setPrinter(ColorPrinter cp){ this.cp=cp; } //安装黑白打印机（重载） public void setPrinter(BlackPrinter bp){ this.bp=bp; } public void print(String content){ if(cp!=null){cp.print(content);}// 注意防止java.lang.NullPointerException if(bp!=null){bp.print(content);} }*/ //拿父类的引用变量作为参数，好处就是可以接收任何其子类的对象 //越抽象的东西越稳定 public void setPrinter(Printer p){ this.p=p; } //******多态.程序设计的时候主体框架使用接口或抽象类，使程序有很好的可扩展性。***** // public void print(String content){ // p.print(content); // } public void print(IInfo info){ p.print(info.detail()); } @Override public String detail() { return "你好我是王牌有限公司"; } } class ColorPrinter extends Printer{ public ColorPrinter(String brand){ super(brand); } //对父类的方法进行重写 public void print(String content){ System.out.println(getbrand()+"彩色打印"+content); } } class BlackPrinter extends Printer{ public BlackPrinter(String brand){ super(brand); } //对父类的方法进行重写 public void print(String content){ System.out.println(getbrand()+"黑白打印"+content); } } class TTeacher implements IInfo{ private String name; private int age; public TTeacher(String name,int age){ super(); this.name = name; this.age = age; } @Override public String detail() { return "你好我的名字叫："+name+"，今年:"+age+"岁."; } }

package com.abc.tzy; public class SoldierDemo { public static void main(String[] args) { Officer s1 = new Officer("军官tzy"); s1.callToAttack(); System.out.println("**********"); s1.callToAttack(s1.getSoldier()[0]);//可以只传s1让自己行动 } } abstract class Soldier{ private String name; public Soldier(String name){ this.name=name; } public String getName(){ return name; } public void start(){ System.out.println("准备攻击。。"); } public void end(){ System.out.println("攻击完成。。"); } public abstract void attack(); public void action(){ start(); attack(); end(); } } class LandSoldier extends Soldier{ public LandSoldier(String name) { super(name); } @Override public void attack() { System.out.println(getName()+"步枪凸凸凸"); } } class OceanSoldier extends Soldier{ public OceanSoldier(String name) { super(name); } @Override public void attack() { System.out.println(getName()+"鱼雷凸凸凸"); } } class Officer extends Soldier{ private Soldier [] soldiers = new Soldier[2];//军官持有2个士兵 public Officer(String name) { super(name); soldiers[0]=new LandSoldier("张三"); soldiers[1]=new OceanSoldier("李四"); } public Soldier[] getSoldier(){ return soldiers; } @Override public void attack() { System.out.println(getName()+"手枪嘟嘟嘟"); } //法号司令（让所有士兵一起打包括自己） public void callToAttack(){ for (int i = 0; i < soldiers.length; i++) { soldiers[i].action();//让每个士兵调用自身行动方法 } this.action();//自己也行动 } //让一个士兵行动 public void callToAttack(Soldier soldier){ soldier.action(); } }