java面向对象的学习

面向对象的学习"/>

java面向对象的学习

面向对象编程oop

面向过程 & 面向对象

面向过程思想：

步骤清晰简单，第一步做什么，第二部做什么…
面向过程比较适合处理一些较为简单的问题

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织(封装)数据

抽象：把很多对象的共同点抽取出来形成类

三大特性：封装(把数据封装起来，对外提供一个接口用来访问）、继承(子类可以继承父类的所有东西)、多态()

从认识论角度考虑是先有对象后有类。对象是指具体的事物。类是抽象的，是对具体事务的抽象。比如狗就是一个类，是对所有的狗个体的抽象，而单独的一条狗就是一个对象。

从代码运行角度考虑是先有类后有对象，类是对象的模板。

回顾方法

• 方法的调用

package com.oop.demo01;
//Demo01 类
public class Demo01 {//main方法 用来启动程序public static void main(String[] args) {//静态方法 直接调用 类名.方法名Student.say();//非静态方法//先实例化这个类 new一个对象Student student = new Student();student.say2();}//static修饰的方法是和类一起加载的，出现的比较早public static void a(){
//        b(); 一个已经存在的去调用一个不存在的方法所以会报错}//类实例化之后才存在public void b(){}
}package com.oop.demo01;//学生类
public class Student {//静态方法  staticpublic static void say(){System.out.println("aaa");}//非静态方法public  void say2(){System.out.println("bbb");}
}

• 值传递

package com.oop.demo01;public class Demo02 {public static void main(String[] args) {int a = 1;change(a);System.out.println(a);//1，因为java是值传递}//返回值为空public static void change(int a){a = 10;}
}

• 引用传递

package com.oop.demo01;//引用传递 一般传递一个对象 本质还是值传递
public class Demo03 {public static void main(String[] args) {Person person = new Person();System.out.println(person.name);//nullchange(person);//person.name引用的是person对象此时对象中的内容被更改过了System.out.println(person.name);//syan}public static void change(Person person){//person是一个对象；更改的是new出来的person对象person.name = "syan";}
}
//一个程序只能有一个public类
//定义了一个person类 有一个属性：name
class Person{String name;//null
}

类与对象的创建

使用new关键字创建对象，一个类中只有属性和方法两样东西

new一个对象时，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

package com.oop.demo02;
//学生类
public class Student {//属性：字段String name;int age;//方法//this就是指当前这个类public void study(){System.out.println(this.name+" is studying");}
}package com.oop.demo02;//一个项目应该只存在一个main方法
public class Application {public static void main(String[] args) {//类是抽象的，需要具体的实例化出来//使用new把类实例化之后会返回一个自己的对象//student对象就是Student类的一个具体实例Student student = new Student();student.name = "syan";student.study();}
}

构造器

类中的构造器也称之为构造方法，实在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：1.必须和类的名字相同 2.必须没有返回类型，也不能写void

没有显示定义的话，在生成class文件中也会默认加了一个没有返回值的Person方法

package com.oop.demo02;//java-->java.class
public class Person {//一个类即使什么都不写也会存在在一个方法名和类名相同的方法(构造器)String name;int age;//显示的定义一个构造器//1.实例化初始值，使用new关键字本质是在调用构造器//2.构造器用来初始化值，也就是初始化上面定义的属性的值//无参构造器public Person(){
//        this.name = "syan";//不写的话默认为null}//有参构造,一旦定义有参构造，无参构造就必须显示定义，否则无参构造就无效了public Person(String name){this.name = name;}
}/* public static void main(String[] args) {Person person = new Person("syan");//这时候走的就是有参构造System.out.println(person.age);System.out.println(person.name);}alt+insert 快速生成*/

创建对象内存分析

package com.oop.demo02;public class Pet {String name;int age;public void shout(){System.out.println("wang!!!");}
}
/*
public class Application {public static void main(String[] args) {Pet dog = new Pet();//调用无参构造，初始化属性值dog.name = "旺财";dog.age = 1;dog.shout();Pet cat = new Pet();}
}*/

第一步加载Application这个类存放在方法区(也属于堆的一部分)中，有静态方法的话一同加载，然后执行main()方法，执行 Pet dog = new Pet()时加载Pet这个类，在堆中存放一个dog引用变量名，同时在堆中开辟空间存储这个新new的dog，且用无参构造初始化值，然后从方法区中的常量池(3不属于常量)中把旺财赋值给name，把3赋值给age，从Pet中调用shout()方法。Pet cat = new Pet()同理…

封装

程序设计追求的就是“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合是指，仅暴露少量的方法给外部使用。

封装(数据的隐藏)

通常应该进制直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。

package com.oop.demo03;/*封装的意义* 1.提高程序的安全性，保护数据* 2.隐藏代码的实现细节* 3.统一接口* 4.系统的可维护性增加了*/public class Student {//属性私有//名字 private :私有private String name;//学号private int id;//性别private char gender;//年龄private int age;//提供一些可以操作这些私有属性的方法//提供一些 public 的get 、set 方法//get：获取这个属性public String getName(){return this.name;}//set：个这个属性赋值public void setName(String name){this.name = name;}//alt + insert 快速生成public int getAge() {return age;}//在set方法中做数据的安全性的判断public void setAge(int age) {if(age>120 || age<0){this.age = 2;}else{this.age = age;}}
}
/*
public class Application {public static void main(String[] args) {Student student = new Student();
//        student.name = "syan";因为name是私有属性不能直接调用student.setName("syan");String name = student.getName();System.out.println(name);student.setAge(888);//不合法的年龄System.out.println(student.getAge());}
}*/

继承

什么是继承

继承的本质是对某一批类的抽象，从而实现对现实数据更好的建模

extends 意思是“扩展”，子类是对父类的扩展。

Java中类只有单继承没有多继承。一个儿子只能有一个爸爸，一个爸爸可以有多个儿子，直接的只能继承一个但间接的可以继承多个，比如每个类都会直接或间接的继承Object类。

继承是类和类之间的一种关系，除此之外类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字 extends来表示。

子类和父类之间，从意义上来讲因该具有“ is a ”的关系

Ctrl + h 打开继承树

package com.oop.demo04;
//人
//在Java中所有的类都默认直接或者间接继承Object类
public class Person {//public//private 父类私有的属性子类不可以继承,但可以操作get，set//default//protected 修饰的属性也可以被直接调用private int money = 10_0000_0000;public void say(){System.out.println("yayaya");}public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}
}package com.oop.demo04;
//学生也是人
public class Student extends Person{
}package com.oop.demo04;
//老师也属于人 子类继承父类拥有父类的全部方法
public class Teacher extends Person{
}package com.oop.demo04;
public class Application {public static void main(String[] args) {Student student = new Student();student.say();System.out.println(student.getMoney());}
}

super

super:

1.super调用父类的构造方法时，必须在子类构造方法中第一行
2.super 必须只能出现在子类的方法或者构造方法中。
3.super和this不能同时出现在构造方法中。

和this对比：

代表的对象不同：this是指本身调用者这个对象，super代表父类对象的引用。

前提条件：this没有继承也可以使用，super只能在继承条件下才可以使用

构造方法：this();本类的无参构造，super()；父类的无参构造。

package com.oop.demo05;
//父类
public class Person {protected String name = "syan";public Person() {System.out.println("Person的无参构造执行");}//private修饰的方法无法被继承public void print(){System.out.println("person");}}

package com.oop.demo05;//子类
public class Student extends Person {private String name = "ccc";public Student() {//new Student()时先调用了父类的无参构造//而且如果父类没有无参构造，子类也无法实现无参构造super();//隐藏代码 调用父类的构造器必须在子类的第一行System.out.println("Student无参构造执行");}public void print(){System.out.println("student");}public void test01(){print();this.print();super.print();}public void test(String name){System.out.println(name);System.out.println(this.name);//super 指的是父类System.out.println(super.name);}
}//主函数
public class Application {public static void main(String[] args) {Student student = new Student();//Person的无参构造执行 Student无参构造执行
//        student.test("aaa");
//        student.test01();}
}

方法的重写

重写：需要有继承关系，子类重写父类的方法。

1.方法名必须相同，参数列表必须相同，方法体不同.

2.重写的方法的修饰符：范围可以扩大但不能缩小。 public>protected>default>private

3.抛出的异常：范围可以缩小但不能扩大。

为什么要重写？

父类的功能，子类不一定需要，或者不一定满足

快捷键 alt+insert --> override 快速生成重写方法

package com.oop.demo05;
//父类
//重写是方法的重写和属性没有任何关系
public class B {protected  void test(){System.out.println("B--test");}
}

package com.oop.demo05;
//子类
public class A extends B{public void test(){System.out.println("A--test");}
}

package com.oop.demo05;public class Application {//静态方法和非静态方法的区别很大//使用静态方法时方法的调用只和左边定义的数据类型有关public static void main(String[] args) {A a = new A();a.test();//父类的引用指向子类B b = new A();//重写只能在非静态方法下而且还必须是public修饰b.test();//子类重写了父类的test方法}
}

多态

什么是多态？

多态即同一方法可以根据发送对象的不同而采用不同的行为方式。

一个对象的实际类型是确定的,但可以指向对象的引用的类型(父类，有关系的类)有很多。

多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象

多态是方法的多态，属性没有多态

package com.oop.demo06;public class Person {public void test(){System.out.println("father");}
}

package com.oop.demo06;public class Student extends Person{@Overridepublic void test() {System.out.println("son");}
}

package com.oop.demo06;public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的
//        new Student();
//        new Person();//可以指向的引用类型是不确定的 ：父类的引用指向子类//子类能使用的方法都是自己的或者继承父类的Student s1 = new Student();//父类型可以指向子类，但不可以调用子类独有的方法Person s2 = new Student();Object s3 = new Student();//对象能执行哪些方法主要看对象左边的类型，父类有的子类没有重写就调用父类的s2.test();//子类重写了父类的方法，执行子类的方法s1.test();}
}

instanceof关键字

instanceof 关键字 （a instanceof b）首先得a和b得有关系否则编译就不通过，如果a是b的实例则输出的就是true否则是false

package com.oop.demo06;public class Application {public static void main(String[] args) {//Object---String//Object---Person---Student//Object---Person---TeacherObject object = new Student();System.out.println(object instanceof Student);//trueSystem.out.println(object instanceof Person);//trueSystem.out.println(object instanceof Object);//trueSystem.out.println(object instanceof Teacher);//falseSystem.out.println(object instanceof String);//falseSystem.out.println("**********************************");Person person = new Student();System.out.println(person instanceof Student);//trueSystem.out.println(person instanceof Person);//trueSystem.out.println(person instanceof Object);//trueSystem.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//不可以比较person和String是同级的System.out.println("**********************************");Student student = new Student();System.out.println(student instanceof Student);//trueSystem.out.println(student instanceof Person);//trueSystem.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//student和Teacher根本无关
//        System.out.println(student instanceof String);//}
}
package com.oop.demo06;
public class Teacher extends Person {
}package com.oop.demo06;
public class Student extends Person{
}

引用类型转换

方便方法的调用，简化代码

package com.oop.demo06;public class Application {public static void main(String[] args) {//类型转换  父(高)   子(低)//Person(高)       Student(低)---不需要强制转换Person person = new Student();//将person强制转换成Student类型就可以使用Student里面的方法了Student s1 = (Student) person;//转换的其实都是对象s1.run();//子类转父类 会丢失一些自己本来的方法Student student = new Student();Person p = student;}
}

static关键字

静态变量和静态方法

package com.oop.demo07;public class Student {public static String name;//静态变量public int age;//非静态变量public void run(){}//静态方法public static void go(){}//有static修饰符的属性和方法是和类一起加载的public static void main(String[] args) {System.out.println(Student.name);//可以直接调用System.out.println(new Student().age);//需要new对象来使用go(); //直接使用new Student().run();//需要new对象}}

静态代码块

package com.oop.demo07;public class Person {//匿名代码块 第二个执行 一般可以用来赋初始值 和对象一起产生{System.out.println("匿名代码块");}//静态代码块 第一个执行和类一起加载而且只执行一次static {System.out.println("静态代码块");}//第三个执行public Person() {System.out.println("无参构造");}public static void main(String[] args) {new Person();System.out.println("*********");new Person();/*执行结果：静态代码块匿名代码块无参构造*********匿名代码块无参构造*/}}

静态导入包

package com.oop.demo07;
//静态导入包
import  static java.lang.Math.random;
import  static java.lang.Math.PI;
public class Test {public static void main(String[] args) {System.out.println(random());//可以直接使用System.out.println(PI);}
}

抽象类

abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类，抽象类中也可以写普通方法

抽象类不能使用new关键字来创建对象，它是用来让子类继承的

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package com.oop.demo08;//抽象类  类 extends 单继承 但接口可以多继承
public abstract class Action {//抽象方法，只有方法名没有方法体 像是一种约束 等着子类实现public abstract void doSth();
}

package com.oop.demo08;
/*抽象类的所有方法，继承了它的子类必须要实现它的抽象方法除非子类也是一个抽象类 */
public class A extends Action{@Overridepublic void doSth() {}
}

接口

普通类只有具体实现；抽象类具体实现和规范(抽象方法)都有

接口：只有规范，自己无法写方法，是一种专业的约束。约束和实现分离：面向接口编程

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。

接口的本质就是契约，就像法律一样，制定好大家都遵守。
oo的精髓就是对对象的抽象，最能体现这一点的就是接口。

接口不能被实例化，接口中也没有构造方法。

package com.oop.demo09;
//使用interface关键字定义关键字  接口都需要有实现类
public interface UserService {//接口中定义的属性默认就是常量 一般不定义属性在接口中public static final int age = 1;//接口中的所有定义其实都是抽象的 默认为 public abstractpublic abstract void add(String name);void delete(String name);void update(String name);void query(String name);}

package com.oop.demo09;public interface TimeService {void time();
}

package com.oop.demo09;//类 可以实现接口 implements接口
//实现接口的类必须重写接口中的方法
//用接口实现了多继承
public class UserServiceImpl implements UserService,TimeService{@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void update(String name) {}@Overridepublic void query(String name) {}@Overridepublic void time() {}
}

内部类

内部类就是在一个类的内部再定义一个类，比如在A类中定义一个B类，那么B类相对A类来说就成为内部类，A类相对于B类就是外部类。

• 成员内部类

package com.oop.demo10;public class Outer {private int age = 1;public void out(){System.out.println("这是外部类的方法");}//成员内部类 可以获得外部类的私有属性 私有方法public class Inner{public void in(){System.out.println("这是内部类的方法");}public void getAge(){System.out.println(age);}}
}

package com.oop.demo10;public class Application {public static void main(String[] args) {Outer outer = new Outer();//通过外部类来实例化内部类Outer.Inner inner = outer.new Inner();inner.getAge();}
}

• 局部内部类

package com.oop.demo10;public class Outer {//局部内部类public void method(){class Inner{}}
}

• 匿名内部类

package com.oop.demo10;public class Test {public static void main(String[] args) {//没有名字初始化类,不用实例保存在变量中new Apple().eat();//其实这个方法会返回一个UserService对象UserService userService = new UserService() {@Overridepublic void a() {}};}
}
class Apple{public void eat(){System.out.println("eat");}
}
interface UserService{void a();
}