Java SE基础之面向对象

面向对象

一、类和对象
1、实际举例：一位同学高考结束，去电脑城买电脑，他要买一个游戏本，CPU、内存、显卡都要高端的，商家就把电脑拿出来给你；这个场景是我们虚构出来的，这就是一个面向对象的过程。

2、类：抽象理解为模子，并不是一个真正的实体
3、属性：一些特征：显卡、内存、CPU
4、对象的方法：打游戏、学习
5、类和对象有什么联系和区别：
类：是一个虚构的东西，是规定那一类的对象
对象：是一个真正的实体，就比如买到手的真正的笔记本

区别：对象是类的具体实现，类是虚的，对象是实的

一、如何定义类：

语法：
[public] class Computer
定义类的一个过程，首先定义它的属性，然后定义它的一个方法；然后创建对象并使用，类名 对象名 = new 类名（）
使用方法：对象名.属性
对象名.方法

新建一个day03的包：在包下新建两个类；
新建一个Computer类：
package day03;
public class Computer{
		String cpu;
		Long memory;

		public void study(){
			System.out.println("我电脑的CPU型号是：" + cpu + "内存是：" + memory);
	}
}

再新建一个ComputerTest类：
package day03;

public class ComputerTest{
	public static void main(String[] args){
			Computer computer = new Computer();
			computer.cpu = "intel";
			computer.memory = 1024L;
			computer.study();

	}
}

1.1、成员变量+局部变量

概述：成员变量是在类中定义的，用来描述对象有什么东西，可以在本类或者其他类中使用（ComputerTest类中也在使用），可以被本类所有方法使用；Computer.java中的cpu和memory就是成员变量。

概述：局部变量：eg：定义在Computer类中的study方法中，只能在这个方法中使用，在其它类中是无法使用的；我们在study方法中定义一个name,它只能在study方法中使用，可以理解为保存的一个临时数据。

一个变量名name，在局部变量和成员变量中都被定义了，局部变量优先级更高，输出的时候优先输出局部变量。

两者区别：
1）作用域不同：成员变量可以没有初始值，但局部变量必须有初始值
2）变量同名：局部变量的优先级更高

public void study(){
		String name = "john";			//此处name需要初始化
		System.out.println(name + "买的电脑的CPU型号是：" + cpu + "内存是" + memory);
}

1.2、构造方法

在创建对象时执行的方法：
方法名和类名相同，没有返回值。
可以有多个构造方法，重载

我们测试了没有构造方法，程序照常能狗运行，这是因为默认·有一个无参的构造方法。
如果有有参的构造方法，就没有默认无参的构造方法了

public class Computer{
		Computer(){
			System.out.println("创建对象")；
	}
意味着，它在创建对象的时候，执行了上面这个方法。

1.3、static关键字

可以修饰的东西：变量、方法、代码块
static一定是一个成员变量（静态成员变量）
在代码中修改：static String type = “DELL”; 他不是一个对象，他是一个类，相当于类中所有对象的type都是DELL；通过 类名.type去访问的。
JVM在加载Computer这个类时，就会在内存中给他分配一个空间，只有当它被卸载时，这个DELL的空间才会被释放。

static String type = "DELL"		//定义类的型号是DELL
Computer.type				//通过类名.	去访问的

又新建一个静态方法：
public static void eat(){
		System.out.println("eat" )
	}

普通方法可以直接调用普通方法，然而静态方法不能调用普通方法，Computer.eat()：类名+方法名使用。static只会在类加载的时候执行一次。

二、封装

在面向对象程序设计方法中，封装（Encapsulation）,一种将抽象性函式接口的实做细节部分包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部定义类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。
概念：想将类的某些信息隐藏，只提供一些方法供外部访问；
封装的主要功能在于我们能够修改自己的实现代码，而不用修改那些调用我们代码的呈现片段。

2.1、概念
2.2、好处
2.3、规范

Computer.java
package day03;

public class Computer{

    static{
        System.out.println("static");
    }
    Computer(){
        System.out.println("创建对象");
    }
    Computer(String cpu1){
        cpu = cpu1;
    }
   private String name;
   private String cpu;
    private Long memory;

    static String type = "DELL";
    static double ScreenSize = 15.6;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    public String getCpu() {
        return cpu;

    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public Long getMemory() {
       return memory;
    }

    public void setMemory(Long memory) {
        if (memory%1024 !=0){
            memory = 0L;
        }
        this.memory = memory;
    }

    public void study(){

        String name = "sail";
        System.out.println(name + "买了一台CPU是" + cpu + "内存是：" + memory);
    }

}

ComputerTest.java中：
	package day03;

public class ComputerTest{
    public static void main(String[] args) {
        Computer computer = new Computer();
        Computer computer1 = new Computer("酷睿");
        computer.setName("john");
        computer.setCpu("amd");
        computer.setMemory(1026L);
        computer.study();
        
    }
}
输出：
static
创建对象
sail买了一台CPU是amd内存是：0

Java封装的例子：
package day04;

    public class EncapTest{ 
        private String name;
        private String idNum;
        private int age;

    public int getAge(){
        return age;
        }

    public String getName(){
        return name;
        }

    public String getIdNum(){
        return idNum;
        }

    public void setAge(int newAge){

        }
    public void setName(String newName){

        }
    public void setIdNum(String newId){

        }
    }
//以上实例中public方法是外部类访问该类成员变量的入口，通常情况下，这些方法被称为setter和getter方法，任何要访问类中私有成员变量的类都要通过这些setter和getter方法。
再举个例子说明EncapTest中类的变量怎样被访问？？

public class RunEncap{
		public static void main(String[] args){
				EncapTest encap = new EncapTest();
		encap.setName("john");
		encap.setAge(24);
		encap.setIdNum("19961209");

		System.out.println("name: " + encap.getName() + " age: " + encap.getAge() + "idNum: " + encap.getIdNum());
}
		}
	
	输出：name: john age: 24idNum: 19961209

2.1 Package

想象成文件夹：a/b/c/d
a.b.c.d
包名命名规范：公司网站倒过来写：org.apache

2.2 修饰符

private：只能在本类中使用
public：
protected：
默认的：

作业？？？从同类，同包（不同类），子类，同项目不同包下是否能访问的到。

2.3 this关键字

this代表当前对象，谁调用，this就是谁，都是对象调用。

public static void eat(){
this.study();
}
报错信息：‘day03.Computer.this’ can’t be referenced from a static context.

2.4内部类

他的功能和普通类类似，但是作用域仅仅在普通类里面。

作业2：重写与重载的区别？

https://blog.csdn.net/zhikanjiani/article/details/96100195

三、继承

概念：类与类之间的一种关系，Java是单继承的（亲老爸只有一个）
好处：a、子类直接拥有父类的所有属性（你爸的房子、车子、钱都是你的），子类不能使用private修饰符。
b、方便代码复用。

在Person类和Student类中都有一个构造方法，当程序执行时，先执行父类中的构造方法，再执行子类中的构造方法

继承关系下的初始化顺序：
先初始化父类，在初始化子类 *****

3.1、Final关键字
可以修饰类，方法，属性，变量（常量）
final修饰的类是不能被继承的，可以想象为一个太监。
测试在public final class Person，它的student子类是不能再继承Person类了，提示信息：can not inherit from final ‘day05.Person’
final修饰的方法也是不能被重写的:
测试在public final void eat() 这个方法中，使用final修饰后，提示在Student类中的eat（）方法不能被重写。
final修饰的属性一定要被初始化。

3.2、super关键字

在子类被重写的方法中加上super.eat();
既能打印出吃大米，也能打印出吃稀饭

@Override
    public void eat() {
        super.eat();
        System.out.println("吃稀饭");
    }

在子类中的Student的构方法中加上super(); 在main主程序中创建对象时在调用构造方法，它的打印是先执行父类构造方法，再执行子类执行方法；为什么打印出来的只有一次，而不是两次，所以我们判定它打印出来的是同一个。

Student(){
        super();
        System.out.println("Student构造方法");
    }

3.3、object
所有的类都继承自object(基类)
其实默认继承了object类；

作业三：object类方法的作用

四、多态

概念：
A：引用多态
父类的引用可以指向子类的对象
Person person2 = new Student();
person2.eat(); //此处执行的还是子类的方法
//Person是父类，指向子类对象；同样都是先初始化父类，再初始化子类。
B：方法多态
创建本类对象调用本类方法；
Person person = new Person();
person.eat();
还有一种是创建子类的对象，调用子类重写的方法或者继承的方法。
注意：子类独有的方法是不能通过父类引用的对象来访问。

在student.class中：
写一个子类独有的方法：
public void eat2(){
	System.out.println("吃烧烤")；
}
在Extends.class中测试：
Person person = new Student();
person.eat2();		//此处注意子类的方法不能通过父类引用的对象来访问。

》》》》》》》》》》》》》》》》》》》》》》
既然这样无法正常访问，可以直接走强制类型转换：
==>Person person = new Student();
if (perosn instanceof Student){
((Student) person).eat2();
}

4.2、引用类型转换：

对象 instanceof 类：判断这个对象是否属于这个类的

4.3抽象类abstract：

a.应用场景：约束子类必须拥有哪些方法，不关注实现

使用：它是用abstract修饰类，修饰抽象方法，不需要实现，仅仅是申明。
如果包含抽象方法，该类一定是抽象类：

public abstract class Teacher {			//一定需要是抽象类
    public abstract void teach();			//抽象方法（1）
	
	public void eat3(){					
		System.out,println("想吃啥就吃啥");				//说明抽象类中不能有非抽象方法
	}
}

------------------------------------------------------------------------------------------------
当我们使用：Teacher teacher = new Teacher();
抽象类不能直接new。

五、接口：

关键字：interface
概念：他定义了一批类必须遵循的规范，也不关心实现细节。

实现：[ 修饰符 ] interface 接口名 | extends 父接口1，父接口2 |

接口可以是继承的，并且可以是多继承的；

public class Jepson extends Ruoze implements Teacher2
既可以继承也可以实现：

抽象类和接口的区别：

抽象类	接口
单继承	可以是多继承
可以包含普通方法	而接口不行