Java基础篇（一）：类与对象--------总结小归纳

╰半夏微凉° 2022-05-24 03:48 208阅读 0赞

** JAVA的世界——万事万物皆对象。**

#### 一、面向对象概念: ####

1.万物皆对象；  
2.将不同类型的数据 抽象出来；  
3.重新定义一种事物，起名后，就是一种类型；  
4.把数据封装到对象中；  
5.使用数据时，使用类的实例；  
6.通过调用实例，来使用我们需要的数据。

#### 二、类： ####

类是对象的模板,对象是类的实例

1.修饰词 class  
class className\{\}  
2.成员变量

3.成员方法（方法中也是把数据、属性、逻辑封装起来）

关于方法——最好一个方法只实现单功能

**   ****修饰词**返回值类型 方法名 (形参)\{  
             方法逻辑......

修饰词有:public、protected、default 和private（作用域从大到小）本文中部会画一张表

返回值类型:    1.void()    逻辑结尾可以使用return;    表示方法结束  
             2.数据类型(基本数据类型或引用数据类型)  
             一定要使用return 具体数据

对象的实例化：(创建对象)  
1.new 构造器(有参传参)  放入堆中  
2.类型 变量 = new 构造器(有参传参)   (地址传递，值传递)  
            （声明）          （创建新地址--堆中）  
  
属性和方法的访问：(调用)  
变量.属性

变量.方法

方法重载：  
1.同一个类中；  
2.方法名相同，参数列表不同；  
3.与参数命名无关，与返回值无关  
方法重载的优势：

方法多态

构造方法：(构造器)  
1.与类名相同  
2.无返回值  
3.格式：修饰词 类名(参数列表)\{  
\}  
**作用：类的初始化(对象属性的初始化)**

this关键字:

指代一个隐式的引用变量

this.属性------就是当前对象

指向未来要创建的对象。主方法new后的对象

public class Person{
    		String name;
    		public Person(String name){  //括号内形参
    		 this.name = name;  //形参与实参的传递
    		}
    	}

构造器也可以重载  
this(有参传参)； 只能放类里第一行  
类的构造器中，调用本类其他构造器，  
  
  
定义类时，如果不定义构造器，系统默认提供一个无参的构造器  
如果定义了构造器，系统取消默认提供的。

**三、JVM内存结构（三大部分）**  
方法区：  
加载硬盘上的类文件，读进到方法区 (Person.class)  
类的所有信息都在此，包括属性，方法等  
堆：  
用来存储类的实例(对象)，会给实例分配相应的空间  
栈：  
存储所有方法的形参，局部变量  
在程序运行期间，当执行到某一个方法时，会在栈中  
给此方法单独分配一个空间------栈帧  
用来存储这个方法包含的所有变量的空间。  
方法执行完毕，栈帧消失，释放内存空间。  
  
  
引用变量，存储的是堆中对象的地址信息。  
**所以我们引入------JVM垃圾回收机制：**  
当有指向对象的变量越来愈多时，有可能造成内存溢出，  
原因是堆里的对象太多，所以有时要**清空变量里的地址信息**

######         String str = "11111";           str = null; ######

此时，堆里的对象没有任何引用，会被认为是垃圾，

被GC(jvm垃圾回收机制)回收

#### **四、继承**： ####

当某一个类的功能不够用时，在 不修改此类的基础上  
将此类的功能扩展到另一个自定义的新类之中  
再扩展其他功能。

特点：

1.子类将父类的**所有属性和方法**都继承下来；  
2.如果父类有private属性或方法，在子类中是不可见的(没有访问的权限)  
3.子类的特有属性/方法，父类不可访问(我的隐私，老爸不准看)

继承的关键字extends

subClass extends superClass\{

subClass 子类，也叫派生类  
superClass 父类，也叫基类、超类  
  
  
**五、方法重写：**  
继承关系，方法名相同，参数列表相同  
1.返回值类型：  
可相同，也可以(子类方法返回值类型是父类方法返回值类型的子类)  
2.修饰词：

可相同，也可以(子类修饰权限大于父类修饰权限)

public>default>protected>private

![70][]

**六、super:**  
 构造方法不能被继承，只能被调用

使用：super(有参传参);

跟前面this();一样，也是只能放到类的第一行。

但是他们倆只能出现其中一种。

![70 1][]

**七、static:**

静态方法：  
 **属于类**的，应该类名.方法名  
Math.random(); //公有资源，谁都可以调。

![70 2][]\--（来自于People类）

\---------------------------------------------------------------------------------------------------------

![70 3][]\--（来自于测试类）

**也可以对象的引用变量调用，但不规范。出现黄色波浪线**  
  
  
非静态方法：  
 **属于对象**，只能用对象调用  
  
  
静态修饰属性：  
也属于类，用类名调用，应该类名.属性名  
//公有资源，谁都可以调。  
通过某一变量修改后，其他变量使用时都是修改后的数据  
  
  
静态代码块：  
static\{  
用于加载资源，如图片，视频，音频等  
         \}  
静态块执行的时机是加载期间，只执行一次  
加载到方法区中。

动态块：\{

执行的时机是new之前，new一次执行一次。

#### 八、final: ####

修饰属性：只能进行初始化，不能进行第二次赋值  
修饰方法：不能被重写  
修饰类：不能被继承  
static final 一起修饰的变量，就是常量。

#### 九、抽象类： ####

abstract修饰  
1.抽象类中可以提供构造器，但是不能被调用  
2.可以有属性  
3.抽象类里不一定都是抽象方法  
4.有抽象方法的类，一定是抽象类  
5.抽象方法没有方法体，即没有 \{\},不能省略abstract，最好使用public修饰  
6.只支持单继承，但可以传递  
7.抽象类与子类的关系  
继承关系，父类可以是抽象类，子类也可以是抽象类。

#### 十、接口：interface ####

1.默认public修饰，不写也是系统提供  
2.接口就是一种规范，默认遵守  
3.实现类的多继承  
  
特点：  
1.不能提供构造器，不能实例化，不被调用  
2.接口里的方法一定是抽象方法，一定是abstract public(可省略)  
3.接口里的属性，一定是常量  
4.接口与接口的关系：可以继承  
  接口与抽象类的关系：实现关系implements  
  接口与普通类的关系：实现关系implements

#### 十一、内部类： ####

当类中需要使用一些数据，不会在其他类中使用，  
    但使用的较为频繁，可定义为内部类  
  
  
  成员内部类：  
内部类对象，一般在外部类中使用，  
内部类中可以直接访问外部类的成员(私有也可访问)。  
原因----有隐式的引用

** 匿名内部类：**最常用

1.隐藏的名字，不显示

2.在方法里写

3.写法如下：

父类|抽象类|接口  = new 父类|抽象类|接口()\{  
方法重写

\};

public class Inner1 {
    	public void sum(int a , int b){
    		System.out.println("Inner1的sum方法"+a+b);
     System.out.println(a+b);
    	}
    }

/*
     * 匿名内部类
     * 父类|抽象类|接口   变量 = new 父类|抽象类|接口(){
    	    	方法的重写
    	    };
     */
    public class TestInner extends Inner1{
    
    	public static void main(String[] args) {
    		Inner1 a1 = new Inner1();
    		a1.sum(5, 6);
    		
    
    		Inner1 a = new Inner1(){
    			@Override                //重写后的方法sum()，方法体里可以改新逻辑
    			public void sum(int a, int b) {
    				super.sum(a, b);    //调用父类的sum(),也可以加别的新东西
    			}
    		};
    		a.sum(3, 4);
    	}
    
    }

运行的结果是：

![70 4][]

**Again，再来一个匿名内部类：**

/*
     * Employee接口，模拟人在单位
     */
    public interface Employee {
    	void work();
    }

/*
     * Family接口，模拟人在家
     */
    public interface Family {
    	void cook();
    	void sleep();
    }

public class Person implements Family,Employee{
    
    	@Override
    	public void work() {
    		System.out.println("Working只能工作");
    	}
    
    	@Override
    	public void cook() {
    		System.out.println("在家能做饭");
    		
    	}
    
    	@Override
    	public void sleep() {
    		System.out.println("在家能睡觉");		
    	}
    
    }

public class Test {
    
    	public static void main(String[] args) {
    		
    		//匿名内部类的实例
    		Family Leo = new Family() {
    			
    			@Override
    			public void sleep() {
    				System.out.println("Leo就不睡觉，起来High");
    			}
    			
    			@Override
    			public void cook() {
    				System.out.println("Neil负责做饭，Leo负责吃");
    			}
    		};
    		Employee Neil = new Employee() {
    			
    			@Override
    			public void work() {
    				System.out.println("Neil上班，老老实实调代码");
    			}
    		};
    		Leo.cook();
    		Leo.sleep();
    		Neil.work();
    	}
    
    }

可见，Leo比较皮，在家天天happy，还要等Neil回来做饭

Neil就比较老实了，加班加点敲代码

### 总结： ###

面向对象的特征：  
  1.封装：  
一块代码的封装---方法  
方法和属性的封装---类  
某些数据的封装---对象  
  
  
优点：  
安全性高，一次封装，到处使用，代码维护性高  
  
  
  2.继承：  
优点：扩展性高，重用性强  
 3. 多态：  
方法的多态；方法的重载与重写  
  
对象的多态：向上转型与向下转型

####  （1）.向上转型：父类型的对象引用子类型的对象，子转父 ####

（会丢失精度）

`                            Dog g = new Animal();`

`                            g.shout();`

#### `  （2）.向下转型：子类型的对象引用父类型的对象，(强制转换)    (可用方法变多)                   ` ####

`                 Animal a = 子类对象(最好是Dog的对象,否则匹配异常)   `

`                 Dog g = (Dog)a;----向下转型      `

`                 验证类型是否匹配： 对象 instanceof 类型  `

`                  属于：返回true          不属于：返回false`

if(a instanceof Dog){
             		Dog g = (Dog)a;
    		}	
    		if(a instanceof Cat){
             		 Cat g = (Cat)a;
    		}

[70]: /images/20220524/a68c823a86be440ba9a3be3a3dcc701d.png
[70 1]: /images/20220524/8dc612771ac84e94829305cb090113ab.png
[70 2]: /images/20220524/896c004e7a7c4d39953a33b00a33b3dd.png
[70 3]: /images/20220524/36b6b7eb1f214da5b42ed1062f9928df.png
[70 4]: /images/20220524/e5dc2d8f7b8a43a696ea9d184ecb0242.png