一 定义面向对象编程的本质是以类的方式组织代码以对象的组织封装数据三大特性封装继承多态二 类与对象的创建new去实例化package opp.Demo2; //学生类 public class Student { ​ //属性字段 String name; int age; ​ //方法 public void study(){ System.out.println(this.name在学习); } ​ } /*public static void main(String[] args) { ​ //类抽象的实例化 // 类实例化后会返回自己的对象 //student对象就是一个Student类的具体实例 ​ Student xiaoming new Student(); Student xiaohong new Student(); ​ xiaoming.name小明; xiaoming.age3; ​ System.out.println(xiaoming.name); System.out.println(xiaoming.age); ​ xiaohong.name小红; xiaohong.age3; ​ System.out.println(xiaohong.name); System.out.println(xiaohong.age); ​ } */三 构造器的使用1和类名相同 2没有返回值 作用 1.new本质在调用方法 2.初始化对象值 注意点 定义有参构造之后如果想使用无参构造显示的定义一个无参的构造快捷键alterinsert改为 鼠标右键加生成package opp.Demo2; ​ public class Person { ​ String name; int age; //无参构造 //1.使用new关键字 //2.用来初始值 public Person() { } //有参构造一旦定义了有参构造无参就必须显式定义 public Person(String name) { this.name name; } // 鼠标右键点击生成altinsertshift可以同时选择俩个 public Person(String name, int age) { this.name name; this.age age; } /* public static void main(String[] args) { ​ //new 实例化了一个对象 Person person new Person(xiaoming,3); ​ System.out.println(person.name); } ​ 构造器 1和类名相同 2没有返回值 作用 1.new本质在调用方法 2.初始化对象值 注意点 1.定义有参构造之后如果想使用无参构造显示的定义一个无参的构造 快捷键alterinsert改为鼠标右键加生成 */ }四 JAVA 三大特性1 封装数据的隐藏通常应禁止直接访问一个对象的数据的实际表示而应通过操作接口来访问这叫信息隐藏属性私有get/setpackage oop.Demo3; /*封装 1.提高程序的安全性保护数据 2隐藏代码的细节 3.统一接口 4.系统的可维护性 */ ​ //类 public class Student { ​ //名字 private String name; //学号 private int id; //性别 private char sex; //年龄 private int age; ​ //get获得这个数据 public String getName() { return this.name; } ​ //set 给这个数据设置值 public void setName(String name) { this.name name; } ​ public int getId() { return id; } ​ public void setId(int id) { this.id id; } ​ public char getSex() { return sex; } ​ public void setSex(char sex) { this.sex sex; } ​ public int getAge() { return age; } ​ public void setAge(int age) { if (age 120 || age 0) { this.age 3; } else { this.age age; } } ​ public static void main(String[] args) { Student s1 new Student(); s1.setName(5780ysys); System.out.println(s1.getName()); ​ ​ s1.setId(123456); System.out.println(s1.getId()); ​ s1.setAge(422); System.out.println(s1.getAge()); ​ } }​2 继承CtrlH可以看到继承关系本质对某一批类的抽象JAVA中类只有单继承,没有多继承!继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。 继承关系的俩个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。 子类和父类之间,从意义上讲应该具有is a的关系.package oop.Demo4; //继承 //Person 人:父类 //所有类都直接或间接继承Object类 public class Person { ​ //public //protected //default //private private int money10_0000_0000; ​ public void say(){ System.out.println(说话了); } ​ public int getMoney() { return money; } ​ public void setMoney(int money) { this.money money; } ​ } /*Application类里面 public static void main(String[] args) { Student student new Student(); student.say(); ​ System.out.println(student.getMoney()); }*/Super类注意Student类中要有形参String name才能使Application导入成功进阶版super注意点 1.super调用父类的构造方法必须在构造方法第一个 2.super必须只能出现在子类的方法或者构造方法中 3.super和this不能同时调用构造方法 VS this 代表的对象不同 this本身调用者这个对象 super代表父类对象的应用 前提 this没有继承也可以使用 super只能在继承条件才可以使用 构造方法 this本类的构造 super父类的构造父类package oop.Demo4; //封装 //Person 人:父类 //所有类都直接或间接继承Object类 public class Person { public Person() { System.out.println(Person实现了父类无参构造);; } ​ protected String namexiangnile; ​ public void print(){ System.out.println(Hello World); } }子类package oop.Demo4; ​ //学生 is 人派生类子类 //子类继承父类的全部方法 public class Student extends Person { private String namexihuanni; ​ public Student() { //隐藏代码调用了父类无参构造 //省略了super.person //注意如果父类直接有参则子类无法调用报错必须子类有super.person(里面为有参) System.out.println(Student实现了子类无参构造); } ​ public void print(){ System.out.println(Hello); } public void test1()/*记住要有形参才能使name可以导入值*/{ print(); this.print(); super.print(); } public void test(String name)/*记住要有形参才能使name可以导入值*/{ System.out.println(name);//喜欢你呀 System.out.println(this.name);//xihuanni System.out.println(super.name);//xiangnile } ​ }Applicationpackage oop; ​ import oop.Demo4.Student; ​ public class Application { public static void main(String[] args) { Student student new Student(); //student.test(喜欢你呀); // student.test1(); ​ ​ /* Person实现了父类无参构造 Student实现了子类无参构造 */ } ​ }方法重写没有static时b调用的是对象的方法而b是用A类new的有static时b调用了B类的方法因为b是用b类定义的因为静态方法是类的方法而非静态是对象的方法即b是A new出来的对象因此调用了A的方法非静态看new右边静态看new左边new 是造对象的不是调用方法的。静态方法不需要对象直接类名调用但类本身依然可以 new 出对象非静态方法用对象 → 看 new 右边多态静态方法用类 → 看声明左边无多态对象调用静态方法只是语法假象实际还是类在调用package oop; ​ import oop.Demo4.A; import oop.Demo4.B; import oop.Demo4.Student; ​ public class Application { public static void main(String[] args) { ​ A anew A(); a.test();//Atest() ​ B bnew A(); b.test();//Atest() ​ } ​ } //非静态的输出结果 //Atest() //Btest()3 多态◆即同一方法可以根据发送对象的不同而采用多种不同的行为方式。 ◆一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多◆多态存在的条件 ◆有继承关系 ◆子类重写父类方法 ◆父类引用指向子类对象◆注意:多态是方法的多态,属性没有多态性。 instanceof1.多态是方法的多态 2.父类和子类有联系 类型转换异常ClassCastException 3.存在条件继承关系方法需要重写父类指向子类对象 Father f1new son();1.static 方法属于类它不属于实例 ​ 2.final 常量 ​ 3.private 方法package oop.Demo5; public class Student extends Person { public void run(){ System.out.println(son); } public void eat(){ System.out.println(好吃); } } /* 1.多态是方法的多态 2.父类和子类有联系 类型转换异常ClassCastException 3.存在条件继承关系方法需要重写父类指向子类对象 Father f1new son(); 1.static 方法属于类它不属于实例 2.final 常量 3.private 方法 */ package oop.Demo5; public class Person { public void run(){ System.out.println(father); } }package oop.Demo5; public class Student extends Person { public void run(){ System.out.println(son); } public void eat(){ System.out.println(好吃); } } /* 1.多态是方法的多态 2.父类和子类有联系 类型转换异常ClassCastException 3.存在条件继承关系方法需要重写父类指向子类对象 Father f1new son(); 1.static 方法属于类它不属于实例 2.final 常量 3.private 方法 */package oop.Demo5; public class Student extends Person { public void run(){ System.out.println(son); } public void eat(){ System.out.println(好吃); } } /* 1.多态是方法的多态 2.父类和子类有联系 类型转换异常ClassCastException 3.存在条件继承关系方法需要重写父类指向子类对象 Father f1new son(); 1.static 方法属于类它不属于实例 2.final 常量 3.private 方法 */类型转换package oop; //类型转换 import oop.Demo5.Person; import oop.Demo5.Student1; import oop.Demo5.Teacher; public class Application { public static void main(String[] args) { Person student1 new Student1(); //student1.go(); //Person obj new Student1() //Student1 student1(Student1)obj; //((Student1)obj).go();强制转换 Person personstudent1; // person.go(); } }五 Static 静态类package oop.Demo6; public class Person { //2.赋初始值 { System.out.println(匿名代码块); } //1.只执行一次 static{ System.out.println(静态代码块); } //3 public Person(){ System.out.println(构造方法); } public static void main(String[] args) { Person person1 new Person(); System.out.println(); Person person2 new Person(); } } 静态代码块 匿名代码块 构造方法 匿名代码块 构造方法静态里面可以用静态不能用非静态可以用new去实例化非静态里面都可以package oop.Demo6; public class Student { private static int age;//静态变量 private double score; public void run(){ } public static void go(){ } public static void main(String[] args) { Student s1 new Student(); s1.run(); } }六 抽象类import oop.Demo5.Person; import oop.Demo5.Student1; import oop.Demo5.Teacher; import oop.Demo7.Action; public class Application { public static void main(String[] args) { //new Action()不能实例化 } } */ package oop.Demo7; //抽象类的所有方法继承了它的子类都必须实现他的方法除非子子类 public class A extends Action{ Override public void doSomething() { } }七 接口普通类:只有具体实现 抽象类:具体实现和规范(抽象方法)都有! 接口:只有规范!接口就是规范,定义的是一组规则,体现了现实世界中“如果你是 ... 则必须能 ... ”的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。接口的本质是契约,就像我们人间的法律一样。package oop.Demo8; public interface TimeService { void timer(); } package oop.Demo8; //抽象的思维~ java 架构师 //interface 定义关键词, public interface UserServices { //接口中所有的定义都是抽象的 public abstract //常量~publicstatic final int AGE12; void add(String name); void delete(String name); void update(String name); void query(String name); }调用上面俩个package oop.Demo8; //抽象类 extends~ //类 可以实现接口 implements接口 //实现了接口的类就需要重写接口中的方法 //多继承利用接口多继承 //ctrlO重写 public class UserServiceImpl implements UserServices,TimeService{ Override public void add(String name) { } Override public void delete(String name) { } Override public void update(String name) { } Override public void query(String name) { } Override public void timer() { } }接口作用 1.约束 2.定义一些方法让不同的人实现 3.public abstract 4.public static final 5.implements可以实现多个接口 6.接口不能被实例化~接口中没有构造方法 7.必须重写接口中的方法 CtrlO八 内部类package oop.Demo9; public class Outer { private int id11; public void out(){ System.out.println(这是外部类方法); } public class Inner{ public void in(){ System.out.println(这是内部类方法); } //获得外部类私有属性 public void getID(){ System.out.println(id); } } } /* 调用输出 package oop; import oop.Demo9.Outer; public class Application { public static void main(String[] args) { //new Outer outer new Outer(); //通过这个外部类来实例化内部类 Outer.Inner inner outer.new Inner(); inner.getID(); } } */package oop.Demo9; public class Test { public static void main(String[] args) { //不用讲实例保存到对象里面 new methods().a(); new UserServices(){ Override public void hello() { } }; } } class methods{ public void a(){ System.out.println(apple); } } interface UserServices{ void hello(); }