一. 面向对象
1.理解面向对象的概念
-
类与对象
-
三大特征：封装示例
封装演示
面向对象: 在调用对象时，除了要指定面向过程中的属性，还要指定该对象可能具有动作。
这是一种主语与谓语的关系
Demo类
package com.example.day01;
import com.example.day01.bean.Demo_TwoBean;
/**面向对象: 在调用对象时，除了要指定面向过程中的属性，还要指定该对象可能具有的动作。
这是一种主语与谓语的关系
*/
public class Demo_two {
public static void main(String[] args){
//调用的无惨构造
new Demo_TwoBean();//没被栈中的变量所使用的对象，将会被回收
Demo_TwoBean tom = new Demo_TwoBean("Tom");
Demo_TwoBean kill = new Demo_TwoBean("Kill", 12);
//方法调用，以及方法的内部调用
System.out.println(tom.toString());
tom.showLove("打游戏");
kill.showTalent("舞蹈");
//调用垃圾回收机制，将无用的对象回收
System.gc();
}
}
面向过程: 在结构体中定义属性，如，姓名 年龄。对 对象操作的函数和对象的自定义没用任何关系。这些函数都需要接受一个代表被操作的对象参数是谓语和宾语的关系
bean类
package com.example.day01.bean;
/**面向过程：在结构体中定义属性，如，姓名 年龄。
对 对象操作的函数和对象的自定义没用任何关系。
这些函数都需要接受一个代表被操作的对象参数
是谓语和宾语的关系
*/
public class Demo_TwoBean {
//属性
private String name;
private int age;
//构造
public Demo_TwoBean() {
}
public Demo_TwoBean(String name) {
this.name = name;
}
public Demo_TwoBean(String name, int age) {
this.name = name;
this.age = age;
}
//get与set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//展示
@Override
public String toString() {
return "Demo_TwoBean{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//爱好
public void showLove(String love){
System.out.println(this.name+"的爱好是 ："+ love);
}
//展示才艺
public void showTalent(String talent){
System.out.println(this.toString()+"Talent :"+ talent);
}
//回收垃圾
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("无用对象回收");
}
}
-
三大特征：继承
继承
继承可以说是一种代码复用的手段，我们在一个现有类上想扩展出一些东西的时候，不需要再次重复编写上面的代码，而是采用一种继承的思想。在派生出的子类里添加一些我们想要的数据或方法，也可以理解为从一般到特殊的过程
super的含义：Super是一个参考（或说指针）指向他紧邻的父类（见下面的例子）。
用super可以指向被隐藏的父类的同名成员。
this与super有什么区别：this表示当前对象，也就是当前类对象，super表示当前类的父类。
package com.example.day01;
public class Deno_four {
public static void main(String[] args){
//子类对象
Student student = new Student();
//通过对象调用父类属性
student.name="张三";
//父类 用start修饰，直接调用
Preson.age = 20;
//通过对象调用子类属性
student.clazz = "1908A";
// 通过对象调用父类方法
student.getInstancec();
//通过对象调用子类方法
System.out.println(student.toString());
}
}
//父类
class Preson{
//private私有的，被private修饰的成员不能被继承
//final 最终的，被final修饰的属性 只能初始化，不能被赋值，可以再构造方法中初始化值
//start 静态的，被start修饰的成员,可以通过类名.调用
//public 公共的，被public修饰的成员，可以被继承，可以通过new 实例化对象
//属性
public String name ;
public static int age;
//构造
public Preson() {
}
public Preson(String name, int age) {
this.name = name;
this.age = age;
}
public void getInstancec(){
System.out.println("name ="+name+"get = "+age);
}
}
//子类
class Student extends Preson{
public String clazz;
//构造
public Student() {
}
//继承父类
public Student(String name, int age) {
//父类的属性
super(name, age);
}
//当前类
public Student(String name, int age, String clazz) {
this(name, age);
this.clazz = clazz;
}
//展示
@Override
public String toString() {
return "Student{" +
"clazz='" + clazz + '\'' +
'}';
}
}
-
三大特征：多态
这里先说运行时多态，其实是指在继承体系中父类的一个接口（必须为虚函数），在子类中有多种不同的实现，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。即通过父类指针或者引用可以访问到子类的接口（虚函数），看上去就像是一个相同的动作，会出现多种不同的结果
Interface与abstract类的区别
抽象类(abstract):
抽象类可以有构造方法，
抽象类中可以有成员变量,因为是用public abstract修饰的
抽象类中的抽象方法的访问类型可以是public，protected
一个类只能继承一个抽象类
接口(Interface):
接口中不能有构造方法。
接口中不能有成员变量，因为是用public static final修饰的
接口中的抽象方法只能用访问类型public
一个类可以实现多个接口
//抽象类可以有构造方法，
//抽象类中可以有成员变量,因为是用public abstract修饰的
// 抽象类中的抽象方法的访问类型可以是public，protected
//一个类只能继承一个抽象类
abstract class Abs_Class{
//变量
String name ;
//构造
public Abs_Class() {
}
//抽象方法
abstract void abs_Method();
}
//接口中不能有构造方法。
//接口中不能有成员变量，因为是用public static final修饰的
//接口中的抽象方法只能用访问类型public
//一个类可以实现多个接口
interface Int_Class{
//常量
String name = "张三";
//方法
void int_Method();
}
二. equals与 ==区别演示
定义常量 String str1 = "abcd"和new String("abcd")的区别
- String str1 = "abcd"的实现过程：
首先栈区创建str引用，然后在String池（独立于栈和堆而存在，存储不可变量）中寻找其指向的内容为"abcd"的对象，如果String池中没有，则创建一个，然后str指向String池中的对象，如果有，则直接将str1指向"abcd"" 如果后来又定义了字符串变量 str2 = "abcd",则直接将str2引用指向String池中已经存在的“abcd”，不再重新创建对象；当str1进行了赋值（str1=“abc”,则str1将不再指向"abcd"，而是重新指String池中的"abc"，此时如果定义String str3 = "abc",进行str1 == str3操作，返回值为true，因为他们的值一样，地址一样，但是如果内容为"abc"的str1进行了字符串的+连接str1 = str1+"d"；此时str1指向的是在堆中新建的内容为"abcd"的对象，即此时进行str1==str2，返回值false，因为地址不一样。 - String str3 = new String("abcd")的实现过程：
直接在堆中创建对象。如果后来又有String str4 = new String("abcd")，str4不会指向之前的对象，而是重新创建一个对象并指向它，
所以如果此时进行str3==str4返回值是false，因为两个对象的地址不一样，如果是str3.equals(str4)，返回true,因为内容相同。
tring title1 = "标题";
String title2 = new String("标题");
String title3 = new String();
title3 = title1;
网友评论