java基础学习-对象Day08
面向对象
面向对象和面向过程
- 面向过程思想：
- 步骤清晰简单，第一步...,第二步...
- 面向过程适合处理一些较为简单的问题
- 面向对象思想：
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对分类进行单独思考。最后，才对每个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
- 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象
- 面向对象编程（Object-Oriented Programming,OOP)
- 面向对象编程的本质就是：以类的方式组织代码，以对象组织（封装）数据。
- 抽象（对象：现实物体，类：按从多个对象中抽象的共同属性划分对象整体）
- 三大特征：
- 封装
- 继承
- 多态
- 从认识论的角度考虑是先有对象再有类。对象是具体的事物，类是对对象的抽象。
- 从代码运行的角度考虑是先有类后有对象，类是对象的模板。
public class Demo01 {
public static void main(String[] args){
//非静态方法调用需要实例化这个类
//实例化：对象类型（类名） 对象名 =对象值
Student student = new Student();
student.say();
}
//修饰符 返回值类型 方法名
//return：方法结束，break：循环结束
public static String sayhello(){
return "hello world";
}
//静态方法内不可直接调用非静态方法，static随着类产生，非静态方法随着对象产生，先产生的不可调用后产生的，只能通过对象调用
public static void a(){
Demo01 demo01 = new Demo01();
demo01.b();
}
//实例化之后才存在
public void b(){
}
}
public class Student {
public void say(){
System.out.println("speak");
}
}
-
引用传递和值传递
//引用传递（对象的值传递） public class Demo04 { public static void main(String[] args) { Person person = new Person();//创建一个Person类的实例对象person System.out.println(person.name);//null（初始值） change(person);//改变实例对象person的name属性 System.out.println(person.name);//jiang可以改变成功 } public static void change(Person person){//改变对象的属性 person.name = "jiang"; } } class Person{//创建一个Person类，定义一个属性：name String name;//初始值为null }//值传递 public class Demo03 { public static void main(String[] args) { int a = 1; System.out.println(a);//1 Demo03.change(a); System.out.println(a);//1 } public static void change(int a){ a = 10; }//10 }
类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但并不能代表某一个具体的事务
- 生物creature，手机，电脑......
- Person类，Pet类，Car类，这些类都是用来描述/定义某一类具体事务应该具备的特点和行为。
- 对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家的狗旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建和初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造起的调用
- 类中的构造器也叫构造方法，是在创建对象时必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
public class Person {
//一个类即使什么都不写也会存在一个（构造）方法
//显式定义一个构造器
String name;
//使用new关键字，本质上是在调用构造器
//用来初始化值
public Person() {
}
//有参构造
//一旦定义了有参构造无参构造就必须显式定义
//有参=无参方法的重载
public Person(String name) {
this.name = name;//当前类的name=方法传入的name
}
}
/*
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质是在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，需要显式的定义一个无参构造
2.this.name=name;当前类的属性（name)=方法传入的name
Alt + insert：创建构造器的快捷方法
*/
public class Student {
//属性：字段
//是Student类的模板，具体的对象才有具体的值
String name;
int age;
//方法
public void study(){
System.out.println(this.name + "在学习");
}
}
/*
类---->属性---->具体对象
人类--->身高体重，年龄，国籍...--->确定具体的人
*/
-
创建对象的内存分析
封装，继承，多态
1.封装
-
该漏的漏，该藏的藏
- 我们设计程序应该追求“高内聚，低耦合”，高内聚就是类的内部数据操作自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用。
-
封装（数据的隐藏）：
- 通常应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，这称为信息隐藏。
-
属性私有：get/set
private String name; private int age; private char sex; /*封装： 1.提高程序的安全性，保护数据 2，隐藏代码的实现细节 3.统一接口 4.系统的可维护性增加 */ //提供一些可以操作这个属性的方法 //提供一些publi的get，set方法 //get：获得这个数据，set：设置数据值 public String getName(){ return this.name; } public void setName(String name){ this.name = name; } public int getAge() { return age; } public void setAge(int age) {//安全性验证 if (age>120 || age<0){ this.age = 0; }else { this.age = age; } }Student s1 = new Student(); s1.setName("jyt"); System.out.println(s1.getName());
2.继承
-
继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
-
extends的意思是“拓展”，子类是父类的拓展
-
java中只有单继承没有多继承
-
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
-
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
-
子类和父类的关系，从意义上讲应该具有“is a”的关系
-
object类
-
super
-
方法重写
//在java中所有类都默认继承Object类 //Person:人（父类） public class Person { private int money = 10_0000_0000; public void say(){ System.out.println("say something"); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } //ctrl + h:查看继承关系树 }//super使用 public class Person { protected String name = "jiang"; public class Student extends Person { private String name = "jyt"; public void test(String name){ System.out.println(name);//蒋，传入test方法的name System.out.println(this.name);//jyt，当前方法（Student）的name System.out.println(super.name);//父类（Person）的属性name } } public class Application { public static void main(String[] args) { Student student = new Student(); student.test("蒋"); } }//父类无参构造 public Person() { System.out.println("Person的无参构造"); } //子类无参构造 public Student() { //隐藏代码，调用了父类的无参构造 super();//隐式调用了，只能写在子类构造器的第一行 System.out.println("Student的无参构造"); }
tips：
-
super：
- super调用父类的构造方法，必须在构造方法的第一个
- super只能出现在子类的构造方法或者方法中
- super和this不能同时调用构造方法（都必须写在第一行）
-
this：
- 和super代表不同的对象
- this：调用者本身这个对象
- super：代表父类对象的引用
- 前提：
- this没有继承关系也可以使用
- super只能在继承关系存在才能使用
- 构造方法：
- this：本类的构造方法
- super：父类的构造方法
- 和super代表不同的对象
-
静态方法：
public class B { //重写都是方法的重写，和属性无关 public static void test(){ System.out.println("B=>test"); } } public class A extends B{ public static void test(){ System.out.println("A=>test"); } } public class Application01 { public static void main(String[] args) { //静态方法 //方法调用只和左边有关 A a = new A(); a.test();//A=>test //父类的引用指向子类 B b = new A(); b.test();//B=>test } } -
非静态方法才可以重写：
public class B { //重写都是方法的重写，和属性无关 public void test(){ System.out.println("B=>test"); } } public class A extends B{ @Override public void test(){ System.out.println("A=>test"); } } public class Application01 { public static void main(String[] args) { //非静态方法：重写 A a = new A(); a.test();//A=>test //子类重写了父类的方法 B b = new A(); b.test();//A=>test } }
tips：（重写）
-
重写：需要有继承关系，子类重写父类的方法
1.参数名称必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大不可以缩小
4.抛出的异常：只能更少不能更多 -
重写： 子类和父类的方法必须一致，方法体不同
-
为什么需要重写：父类的功能子类不一定需要或不一定满足。
3.多态
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确定的，但可以指向的引用类型有很多
-
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类
-
注意：多态是方法的多态，属性没有多态
-
instanceof：（类型转换）引用类型
public class Person { public void run(){ System.out.println("run"); } public void speak(){ System.out.println("say"); } } public class Student extends Person{ @Override public void run() { System.out.println("son"); } public void eat(){ System.out.println("eat"); } } public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的（new出来的类型） //new Student：Student类型 //new Person：Person类型 //可指向的引用类型具有多样性，父类的引用指向子类 //对象可以调用的方法主要看左边，和右边没有关系 Student s1 = new Student();//Student能调用的方法都是自己的或者是继承自父类的 Person s2 = new Student();//Person父类型，可以指向子类但是不能调用子类独有的方法 Object s3 = new Student(); s1.run(); s1.speak(); s2.run();//子类重写了父类的方法，执行子类 s1.eat(); ((Student)s2).eat(); } } -
多态：
1.多态是方法的多态，属性没有多态
2.父类和子类，存在关系，类型转换异常（ClassCastException）
3，存在条件：继承关系，方法重写 -
不可实现多态：
1.static方法属于类不属于实例对象
2.final修饰的为常量
3.private私有方法//Object > Person,String >Student,Teacher //System.out.println(x instanceof y);若x的引用类型同y有父子关系则可以编译通过，若x的实际类型和y有父子关系则为true Object object = new Student(); System.out.println(object instanceof Student);//true System.out.println(object instanceof Person);//true System.out.println(object instanceof Object);//true System.out.println(object instanceof String);//false System.out.println(object instanceof Teacher);//false Person person = new Student(); System.out.println(person instanceof Student);//true System.out.println(person instanceof Person);//true System.out.println(person instanceof Object);//true //同类别编译不通过System.out.println(person instanceof String); System.out.println(person instanceof Teacher);//person实际指向类型为Student，无父子关系，false -
instanceof：
-
System.out.println(x instanceof y);
-
可编译：x的引用类型同y有线型父子关系
-
结果：x的实际类型和y有线型父子关系则为true，反之为false
//类型转换 高转低(向下转型）：强制转换，低转高（向上转型）：自动转换 Person student = new Student(); ((Student)student).eat();//向下自动转型（类型）对象 Person person = student;//向上转型自动转 //person.eat();//报错，子类丢失了自己本身的一些方法 /* 1.父类引用指向子类对象 2，把子类型转换为父类，向上自动转型 3.把父类转换为子类向下强制转换 4，方便方法的调用，减少重复的代码 */ -
static关键字
-
静态变量（类变量）和非静态变量（实例变量）
private static int age;//静态（类）变量：所有对象可调用，利于多线程 private double score;//实例（对象）变量 public static void main(String[] args) { Student s1 = new Student(); System.out.println(s1.score); System.out.println(s1.age); System.out.println(Student.age);//static随着类创建产生，可以直接使用类名调用 } -
静态方法和非静态方法
public static void teach(){//静态方法 System.out.println("teach"); } public void say(){//非静态方法 } public static void main(String[] args) { teach();//静态方法可以直接调用 new Teacher().say();//实例化一个对象才可以调用非静态方法 //静态方法中不可调用非静态方法：因为静态方法随着和类同时产生，非静态方法和对象同时产生，静态方法早于非静态产生 } -
加载顺序：静态(加载一次）---->匿名------>构造方法
//2. { System.out.println("匿名代码块"); } //1.只执行一次 static { System.out.println("静态代码块"); } //3. public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person p1 = new Person(); System.out.println("======================="); Person p2 = new Person(); } } 输出结果： 静态代码块 匿名代码块 构造方法 ======================= 匿名代码块 构造方法 -
拓展：静态导入包
//静态导入包 import static java.lang.Math.random; public class Test { public static void main(String[] args) { System.out.println(random());//不需要Math.了 } }
抽象类
-
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，该方法即为抽象方法，如果修饰类，该类即为抽象类
-
抽象类中可以没有抽象方法，但是含抽象方法的类一定是抽象类
-
抽象类不可以使用new关键字来实例化，它是让子类来继承的
-
抽象方法只有方法的声明，没有方法的实现，它是让子类来实现的
-
子类继承抽象类就必须实现抽象类中没有实现的抽象方法，除非该子类也声明为抽象类
//抽象类abstract(类：使用extends实现，只有单继承（局限性）） public abstract class Action { //是一个约束，希望有人帮我们实现 //abstract，抽象方法，只有方法名，没有具体实现 public abstract void doSomething(); //1.抽象类不能new出来(不能被实例化），只能靠子类去实现，是一个大的空框架 //2.抽象类里可以写普通方法，但是抽象方法必须写在抽象类里 }//抽象类的所有方法，继承了抽象类的子类都需要帮它实现（重写），除非该子类也是抽象类 public class A extends Action { @Override public void doSomething() { } }
接口
-
普通类：只有具体实现
-
抽象类：具体实现和规范（抽象方法）都有
-
接口：只有规范（抽象方法）
-
接口就是规范，定义的是一组规则
-
接口的本质是契约，制定好大家都去遵守
-
OO的精髓就是对对象的抽象，最能体现出抽象的就是接口，设计模式的研究就是如何合理的抽象
//interface:定义接口，接口都需要实现类 public interface UserService { //接口中都是常量，修饰符为public static final int age = 99; //接口中的方法都是抽象的public abstract类型 void add(); void delete(); void insert(); void query(); } public interface TimeService { void timer(); }//抽象类：extends //接口：implements //实现了接口的类必须重写接口里的方法 public class UserServiceImpl implements UserService,TimeService { @Override public void add() { } @Override public void delete() { } @Override public void insert() { } @Override public void query() { } @Override public void timer() { } } -
接口作用：
- 一种约束，一种框架
- 定义一些方法，让不同的人去实现
- public abstract ：修饰方法
- public static final ：修饰常量
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
- 接口中的方法必须被重写
多种内部类
-
内部类就是在类的内部在定义一个类，例如：在A的内部定义了一个B类，那么B对A来说就称为内部类，A对B就是外部类
-
分类：
- 成员内部类、
- 静态内部类
- 局部内部类
- 匿名内部类
public class Outer { private int id = 10; public void outer(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //可以获取外部类的私有属性 public void getID(){ System.out.println(id); } } }public class Application { public static void main(String[] args) { Outer outer = new Outer(); //内部类通过它的外部类来实例化 Outer.Inner inner = outer.new Inner(); inner.in(); inner.getID(); } }public class Test01 { public static void main(String[] args) { Apple apple = new Apple();//一个名为apple的Apple类对象 //没有名字初始化类(匿名对象),不用把实例保存到变量当中去 new Apple().eat(); //实现了接口的类，也没有名字（匿名内部类） new UserService(){//UserService userService(类名） = new UserService() public void hello() { } }; } } class Apple{ public void eat(){ System.out.println("eat"); } } interface UserService{ void hello(); }public class Test { public void method(){ //局部内部类 class Inner{ public void in(){ } } } }