package oo.day01;//学生类public class Student {//成员变量String name;int age;String address;//方法void study() {System.out.println(name+"在学习...");}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);}}
package oo.day01;//学生类的测试类public class StudentTest {public static void main(String[] args) {//创建学生对象Student zs = new Student();//给成员变量赋值zs.name = "zhangsan";zs.age = 25;zs.address = "河北廊坊";//调用方法zs.study();zs.sayHi();Student ls = new Student();ls.name = "lisi";ls.age = 26;ls.address = "黑龙江佳木斯";ls.study();ls.sayHi();//1)创建了一个学生对象//2)给所有成员变量赋默认值Student ww = new Student();ww.study();ww.sayHi();}}
package oo.day02;//构造方法和this的演示public class ConsDemo {public static void main(String[] args) {Student zs = new Student();Student ls = new Student("lisi",25,"LF");zs.sayHi();ls.sayHi();}}
package oo.day02;//重载的演示public class OverloadDemo {public static void main(String[] args) {Aoo o = new Aoo();o.say();o.say("zhangsan");o.say(25);o.say("zhangsan", 25);o.say(25, "zhangsan");}}class Aoo{void say() {}void say(String name) {}void say(int age) {}void say(String name,int age) {}void say(int age,String name) {}//int say() {return 1;} //编译错误，重载与返回值类型无关//void say(String address) {} //编译错误，重载与参数名称无关}
package oo.day02;//学生类public class Student {String name;int age;String address;//构造方法Student(){this("无名氏",1,"未知"); //调用构造方法}Student(String name,int age,String address){this.name = name;this.age = age;this.address = address;}void study() {System.out.println(name+"在学习...");}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);}}
package oo.day03;//引用类型数组的演示public class ArrayDemo {public static void main(String[] args) {Student[] stus = new Student[3]; //创建Student数组对象stus[0] = new Student("zs",25,"LF"); //创建Student对象stus[1] = new Student("ls",26,"JMS");stus[2] = new Student("ww",28,"SD");System.out.println(stus[0].name); //输出第1个学生的名字stus[1].age = 24; //修改第2个学生的年龄为24stus[2].sayHi(); //第3个学生跟大家问好for(int i=0;i<stus.length;i++) { //遍历所有学生System.out.println(stus[i].name); //输出每个学生的名字stus[i].sayHi(); //每个学生跟大家问好}Student[] ss = new Student[]{ //了解new Student("zs",25,"LF"),new Student("ls",26,"JMS"),new Student("ww",28,"SD")};}}
package oo.day03;//学生类public class Student {String name;int age;String address;//构造方法Student(){this("无名氏",1,"未知"); //调用构造方法}Student(String name,int age,String address){this.name = name;this.age = age;this.address = address;}void study() {System.out.println(name+"在学习...");}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);}}
package oo.day03;//super的演示public class SuperDemo {public static void main(String[] args) {Boo o = new Boo();}}class Coo{Coo(int a){}}class Doo extends Coo{Doo(){super(5);}/*//如下代码为默认的Doo(){super();}*/}class Aoo{Aoo(){System.out.println("超类构造");}}class Boo extends Aoo{Boo(){//super(); //默认的，调用超类的无参构造System.out.println("派生类构造");}}
package oo.day04;public class Test {public static void main(String[] args) {Student[] stus = new Student[3];stus[0] = new Student("aaa",25,"LF","111");stus[1] = new Student("bbb",24,"JMS","222");stus[2] = new Student("ccc",26,"SX","333");for(int i=0;i<stus.length;i++) {System.out.println(stus[i].name);stus[i].sayHi();}Teacher[] tes = new Teacher[3];tes[0] = new Teacher("ddd",35,"LF",5000);tes[1] = new Teacher("eee",44,"JMS",8000);tes[2] = new Teacher("fff",56,"SD",10000);for(int i=0;i<tes.length;i++) {System.out.println(tes[i].name);tes[i].sayHi();}Doctor[] docs = new Doctor[2];docs[0] = new Doctor("ggg",35,"LF","主治医师");docs[1] = new Doctor("hhh",44,"LF","副主任医师");for(int i=0;i<docs.length;i++) {System.out.println(stus[i].name);docs[i].sayHi();}}}class Person{String name;int age;String address;Person(String name,int age,String address){this.name = name;this.age = age;this.address = address;}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);}}class Student extends Person{String stuId; //学号Student(String name,int age,String address,String stuId){super(name,age,address);this.stuId = stuId;}}class Teacher extends Person{double salary; //工资Teacher(String name,int age,String address,double salary){super(name,age,address);this.salary = salary;}}class Doctor extends Person{String level; //职称Doctor(String name,int age,String address,String level){super(name,age,address);this.level = level;}}
package oo.day04;//重写的演示public class OverrideDemo {public static void main(String[] args) {}}//超类大，派生类小class Coo{void show() {}double test() {return 0.0;}Doo say() {return null;}Coo sayHi() {return null;}}class Doo extends Coo{//int show() {return 5;} //编译错误，void时必须相同//int test() {return 0;} //编译错误，基本类型时必须相同//Coo say() {return null;} //编译错误，引用类型时必须小于或等于Doo sayHi() {return null;} //正确，小于或等于}
package oo.day04;//重写与重载区别的演示public class OverrideOverloadDemo {public static void main(String[] args) {Eoo eoo = new Eoo(); //想调show()方法必须创建Eoo对象Aoo o = new Boo(); //想调show()方法必须得传参eoo.show(o); //重载方法被调用时，看参数的类型}}class Eoo{void show(Aoo o) {System.out.println("超类型参数");}void show(Boo o) {System.out.println("派生类型参数");}}class Aoo{int a;void show() {}}class Boo extends Aoo{int b;void test() {}}
package oo.day04;public class Test {public static void main(String[] args) {Person[] ps = new Person[5];ps[0] = new Student("zhangsan",25,"LF","111"); //向上造型ps[1] = new Student("lisi",26,"JMS","222");ps[2] = new Teacher("wangwu",35,"SD",8000.0);ps[3] = new Teacher("zhaoliu",46,"SX",18000.0);ps[4] = new Doctor("sunqi",35,"LF","主任医师");for(int i=0;i<ps.length;i++) {System.out.println(ps[i].name);ps[i].sayHi();}//重写方法被调用时，看对象的类型----规定Student zs = new Student("zhangsan",25,"LF","111");Person s = new Student("zhangsan",25,"LF","111");zs.sayHi(); //调用Student类的sayHi()s.sayHi(); //调用Student类的sayHi()}}class Person{String name;int age;String address;Person(String name,int age,String address){this.name = name;this.age = age;this.address = address;}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address);}}class Student extends Person{String stuId; //学号Student(String name,int age,String address,String stuId){super(name,age,address);this.stuId = stuId;}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，学号为:"+stuId);}}class Teacher extends Person{double salary; //工资Teacher(String name,int age,String address,double salary){super(name,age,address);this.salary = salary;}void sayHi() {System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address+"，工资为:"+salary);}}class Doctor extends Person{String level; //职称Doctor(String name,int age,String address,String level){super(name,age,address);this.level = level;}}
package oo.day04;//向上造型的演示public class UploadDemo {public static void main(String[] args) {Aoo1 o1 = new Aoo1();o1.a = 1;o1.show();//o1.b = 2; //编译错误，超类不能访问派生类的Boo1 o2 = new Boo1();o2.b = 1;o2.test();o2.a = 2; //正确，派生类可以访问超类的o2.show();Aoo1 o3 = new Boo1(); //向上造型o3.a = 1;o3.show();//o3.b = 2; //编译错误，能点出来什么，看引用o3的类型//o3.test(); //编译错误}}class Aoo1{int a;void show() {}}class Boo1 extends Aoo1{int b;void test() {}}
package oo.day05;//访问控制修饰符的演示public class Aoo {public int a; //任何类protected int b; //本类、派生类、同包类int c; //本类、同包类private int d; //本类void show() {a = 1;b = 2;c = 3;d = 4;}}class Boo{ //演示privatevoid show() {Aoo o = new Aoo();o.a = 1;o.b = 2;o.c = 3;//o.d = 4; //编译错误}}
package oo.day05.vis;import oo.day05.Aoo;public class Coo { //演示同包的void show() {Aoo o = new Aoo();o.a = 1;//o.b = 2; //编译错误//o.c = 3; //编译错误//o.d = 4; //编译错误}}class Doo extends Aoo{ //跨包继承，演示protectedvoid show() {a = 1;b = 2;//c = 3; //编译错误//d = 4; //编译错误}}
package oo.day05;//final的演示public class FinalDemo {public static void main(String[] args) {}}//演示final修饰类final class Hoo{}//class Ioo extends Hoo{} //编译错误，final的类不能被继承class Joo{}final class Koo extends Joo{} //正确，final的类不能当老爸，但能当儿子//演示final修饰方法class Foo{final void show() {}void test() {}}class Goo extends Foo{//void show() {} //编译错误，final的方法不能被重写void test() {}}//演示final修饰变量class Eoo{final int a = 5;void test() {//a = 8; //编译错误，final的变量不能被改变final int b = 55;//b = 88; //编译错误，final的变量不能被改变}}
package oo.day05;//static的演示public class StaticDemo {public static void main(String[] args) {Loo o1 = new Loo();o1.show();Loo o2 = new Loo();o2.show();Loo o3 = new Loo();o3.show();System.out.println(Loo.b); //常常通过类名点来访问Moo.test(); //常常通过类名点来访问Noo o4 = new Noo();Noo o5 = new Noo();Noo o6 = new Noo();}}class Noo{ //演示静态块static {System.out.println("静态块");}Noo(){System.out.println("构造方法");}}class Moo{ //演示静态方法int a; //实例变量(由对象点来访问)static int b; //静态变量(由类名点来访问)void show() { //有隐式thisSystem.out.println(this.a);System.out.println(Moo.b);}static void test() { //没有隐式this//静态方法中没有隐式的this传递//没有this就意味着没有对象//而实例变量a必须通过对象名来访问//所以如下语句发生编译错误//System.out.println(a); //编译错误System.out.println(Moo.b);}}class Loo{ //演示静态变量int a;static int b;Loo(){a++;b++;}void show() {System.out.println("a="+a+",b="+b);}}
package oo.day06;//static final常量的演示public class StaticFinalDemo {public static void main(String[] args) {System.out.println(Aoo.PI); //常常通过类名点来访问//Aoo.PI = 3.1415926; //编译错误，常量不能被改变//1)加载Boo.class到方法区//2)静态变量num一并存储到方法区中//3)到方法区中获取num的值并输出System.out.println(Boo.num);//编译器在编译时会将常量直接替换为具体的值，效率高//相当于System.out.println(5);System.out.println(Boo.COUNT);}}class Boo{public static int num = 5; //静态变量public static final int COUNT = 5; //常量}class Aoo{public static final double PI = 3.14159;//public static final int NUM; //编译错误，常量必须声明同时初始化}
package oo.day07;//成员内部类的演示public class InnerClassDemo {public static void main(String[] args) {Mama m = new Mama();//Baby b = new Baby(); //编译错误，内部类对外不具备可见性}}class Mama{ //外部类private String name;void create() {Baby b = new Baby(); //正确}class Baby{ //内部类void showName() {System.out.println(name);System.out.println(Mama.this.name);//System.out.println(this.name); //编译错误，this表示当前Baby对象}}}
package oo.day07;//匿名内部类的演示public class NstInnerClassDemo {public static void main(String[] args) {//1)创建了Aoo的一个派生类，但是没有名字//2)为该派生类创建了一个对象，名为o1//3)大括号中的为派生类的类体Aoo o1 = new Aoo() {};//1)创建了Aoo的一个派生类，但是没有名字//2)为该派生类创建了一个对象，名为o2//3)大括号中的为派生类的类体Aoo o2 = new Aoo() {};final int num = 5;//1)创建了Boo的一个派生类，但是没有名字//2)为该派生类创建了一个对象，名为o3//3)大括号中的为派生类的类体Boo o3 = new Boo() {void show() {System.out.println("showshow");System.out.println(num); //JDK1.7(含)以前要求该变量必须是final的}};o3.show();}}abstract class Boo{abstract void show();}abstract class Aoo{}
package oo.day08;//接口的演示public class InterDemo {public static void main(String[] args) {//Inter3 o1 = new Inter3(); //编译错误，接口不能被实例化Inter3 o2 = new Coo(); //向上造型Inter2 o3 = new Coo(); //向上造型}}interface Inter2{ void say();}interface Inter3 extends Inter2{void sayHello();}class Coo implements Inter3{public void sayHello() {}public void say() {}}interface Inter1{void show(); //接口中成员默认访问权限为public的void test();}abstract class Aoo{abstract void sayHi();}class Boo extends Aoo implements Inter1,Inter2{public void show() {} //类中成员默认访问权限为默认的public void test() {}public void say() {}void sayHi() {}}//演示接口的语法interface Inter{public static final int NUM = 5;public abstract void show();double PI = 3.14159; //默认public static finalvoid test(); //默认public abstract//int count; //编译错误，常量必须声明同时初始化//void sayHi() {} //编译错误，抽象方法不能有方法体}
package oo.day09;//多态的演示public class MultiTypeDemo {public static void main(String[] args) {Aoo o = new Boo(); //向上造型Boo o1 = (Boo)o; //引用o所指向的对象就是Boo类型Inter o2 = (Inter)o; //引用o所指向的对象实现了Inter接口//Coo o3 = (Coo)o; //运行时发生ClassCastException类型转换异常if(o instanceof Coo) { //建议强转时都要做这样判断，此处为falseCoo o4 = (Coo)o;}else {System.out.println("o不是Coo类型");}}}interface Inter{}class Aoo{}class Boo extends Aoo implements Inter{}class Coo extends Aoo{}
package oo.day10;import java.util.Arrays;//补充内容public class Test {public static void main(String[] args) {/*int[] arr = {34,6,16,3,89};//将arr数组转换为字符串并输出System.out.println(Arrays.toString(arr));*/Student zs = new Student();zs.setName("zhangsan");System.out.println(zs.getName());zs.setAge(25);int age = zs.getAge();System.out.println(age);}}class Student{private String name;private int age;public void setName(String name) { //赋值this.name = name;}public String getName() { //取值return name;}public void setAge(int age) { //赋值this.age = age;}public int getAge() { //取值return age;}}
