Java 第五天笔记

缺乏、安全感 2022-05-15 08:18 235阅读 0赞

1 垃圾回收机制

（1）程序员无权调用垃圾回收器

（2） 收集并删除未引用的对象。可以通过调用*"System.gc()"*来触发垃圾回收，但并不保证会确实进行垃圾回收。JVM的垃圾回收只收集哪些由**new**关键字创建的对象。所以，如果不是用**new**创建的对象，你可以使用**finalize函数**来执行清理。

2 构造函数

（1）构造方法的作用：

构造方法作用：对对象进行初始化.

构造函数与普通函数的区别：

（1）. 一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。

（2）. 构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。

（3）. 普通函数可以使用对象多次调用，构造函数就在创建对象时调用。

（4）. 构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。

（5）. 构造函数没有返回值类型。

构造函数要注意的细节：

（1）. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。

备注：可以通过javap命令验证。

（2）.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

.构造代码块：

构造代码块作用：给所有的对象进行统一的初始化。 具体作用：

1：给对象进行初始化。对象一建立就运行并且优先于构造函数。

2：与构造函数区别

A：构造代码块和构造函数的区别，构造代码块是给所有对象进行统一初始化， 构造函数给对应的对象初始化。

B：构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。

3 重载

A 方法的重载是指一个类中可以定义名字相同但是参数不同的方法。调用时，会根据不同的参数来调用对应的函数

B： 两同三不同：

同一个类，同一个方法名，

不同是 ：参数列表不同（类型，个数，顺序）

只有返还值不同不构成方法的重载（）如 int a(String sgtr)\{\} ,void a(String i)\{\}

只有形参的名称不同，不构成方法的重载

与普通方法一样。构造方法也可以重载

4 static 关键字（非静态可以调用静态的，但是静态的不可以调用非静态的）

在类中 用static 关键字声明的成员变量为静态变量，或者叫做类属性，类变量

：它是该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显示初始化，，对于该类的所有对象来说，static成员变量只有一份。该类的所有对象共享！可以使用对象类属性来调用。不过一般都是使用类名。类属性。static变量至于方法区中。

用static声明方法为静态方法：不需要对象就可以通过(类名.方法名)调用。在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可以访问非static 成员。

5 this关键字（常用于构造方法中（且在一个构造方法中调用另一个构造函数时this(也可以还有参数)：必须在这个构造器的第一行），初始化变量，和set和get方法中）

public Student02(String name,int id)\{  
this(); //必须位于第一行  
this.name = name; //this.name代指当前对象  
this.id = id;  
\}  
public Student02()\{  
System.out.println("构造一个对象");  
\}

在普通方法中this总是指向调用该方法的对象；在构造函数中this总是指向正要初始化的对象；this不能用于static方法。

6 面向对象三大特征

A:继承：类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。；提高代码的复用性！；extends关键字的意思是扩展，子类是父类的扩展。

子类继承父类，可以得到父类的全部属性和方法（除了父类构造方法）。Java中只有单继承（一个类只有一个直接父类），没有多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。Java的多继承可以通过接口来实现，，如果定义一个类时，没有调用extends，则它的父类是：Java.lang.Object。不同的说法：超类，父类，子类，派生类。

public class Animal \{  
String eye;  
public void run()\{  
System.out.println("跑");  
\}  
public void eat()\{  
System.out.println("吃");  
\}  
public void sleep()\{  
System.out.println("睡");  
\}  
\}  
class Mammal extends Animal\{  
public void taiSheng()\{  
System.out.println("胎生");  
\}  
\}  
class Paxing extends Animal\{ //  
public void eggSheng()\{  
System.out.println("卵生");  
\}  
\}  
class Bird extends Animal\{  
  
public void run()\{ //重写父类方法(重写后覆盖父类方法)  
super.run(); //super调用父类的方法  
System.out.println("飞");  
\}  
public void eggSheng()\{  
System.out.println("卵生");  
\}  
\}

继承涉及的方法重写：在子类中可以根据需要对从父类继承的方法进行重写。重写的方法必须和被重写的方法具有相同的方法名称，参数列表和返回值类型。，重写方法不能使用比被重写方法更严格的访问权限。（由于多态）

Object类： 该类是所有Java类的根基类

如果在类中声明中未使用extends关键字指明其基类那么该类的基类默认为Object类

public class People\{ \} 默认继承 public class People extends Object\{\}

重写：toString方法:默认返回：包名+类名+@+哈希码（根据对象内存位置生成，唯一不重复）。 可以重写

# 封装 #

--------------------

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

### 封装的优点 ###

*  1. 良好的封装能够减少耦合。
 *  2. 类内部的结构可以自由修改。
 *  3. 可以对成员变量进行更精确的控制。
 *  4. 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如

public class Person \{ private String name; private int age; \}这段代码中，将 **name** 和 **age** 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person\{

private String name; private int age;

public int getAge()\{

return age;

public String getName()\{

return name;

public void setAge(int age)\{

this.age = age;

public void setName(String name)\{

this.name = name;

以上实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

# Java public private protected #

（1）访问权限修饰符修饰成员变量和方法  
public：表明该成员变量和方法是共有的，能在任何情况下被访问。  
protected：必须在同一包中才能被访问，但是对于子类来说即使不同包的子类也可以访问。

default:默认可以在同一个类，同一个包中访问

private：只能在本类中访问。

实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

（2）访问权限修饰符修饰类  
不能用protected和private修饰类

**多态 ：**简单的理解就是事物的多种形态。专业的术语说就是：同一个实现接口，使用不同的实例而执行不同的操作。

package zyl.oop.duotai;

public class Animal \{  
String string;  
public void voice()\{  
System.out.println("普通动物叫声");  
\}  
\}  
class Cat extends Animal\{  
public void voice()\{  
System.out.println("喵喵");  
\}  
\}  
class Dog extends Animal\{  
public void voice()\{  
System.out.println("旺旺");  
\}  
\}  
class Pig extends Animal\{  
public void voice()\{  
System.out.println("哼哼");  
\}  
\}

package zyl.oop.duotai;

public class Test \{  
public static void testvoice(Animal a)\{  
a.voice();  
\}  
// public static void testvoice(Cat c)\{  
// c.voice();  
// \}  
// public static void testvoice(Dog d)\{  
// d.voice();  
// \}  
// public static void testvoice(Pig p)\{  
// p.voice();  
// \}  
public static void main(String\[\] args) \{  
// Cat c = new Cat();  
// Animal a = c;  
Animal a = new Cat();//父类的引用指向一个子类对象 构成多态  
testvoice(a);  
Animal b = new Dog();  
testvoice(b);  
Animal c = new Pig();  
testvoice(c);  
\}

结果 ：喵喵  
旺旺  
哼哼  
  
从上面的代码可以看出我们在传一个Cat Dog等类对象的时候，我们进行了一个子类到父类的转换（向上转型），这时候调用testvoice(a),testvoice(b)testvoice(c)方法不是调用的父类的，而是指向子类的。

子类转换父类的规则

1.将一个父类的引用指向一个子类对象时，称向上转型，自动进行类型转换。

2.此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法。

3.父类无法调用子类特有的数据。

结论

1.继承的存在（无继承，无多态，继承是多态的基础）

2.子类要重写父类的方法（多态下调用子类重写后的方法）

3.父类引用变量指向子类对象（子类到父类的类型转换）