文章目录
1 Java的面向对象
1.1 面向对象三大特征之封装
-
在java中包的概念就是和文件夹的概念类似，同样，包的存在是为了解决文件太乱不好管理和文件同名问题。java中的包package等同于文件夹的概念，包和文件夹一样可以有多级。引入方式 在最前面使用import 将包引入。
-
封装和隐藏：直接对属性进行更改有问题，这时需要对属性进行信息隐藏（声明私有，private）。
-
访问权限修饰符：
private：只有类内部能访问。
缺省：类内部和包内。
protected:类内部、包内、子类。
public：任何地方。 -
JaveBean：是一种Java语言写成的可重用组件。JavaBean，是指符合如下标准的Java类；
- 类是公共的
- 有一个无参的公共的构造器。
- 有属性，属性一般是私有的，具有对应的get、set方法。
1.2 面向对象三大特征之继承
- 不要仅为获取某个类中某个功能而去继承
- 继承的出现提高了代码的复用性
- 子类不是父类的子集，而是对父类的扩展。
- 一个子类只能有一个父类, 父类能有多个子类。
- 关键字super
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造方法中调用父类的构造器
- super可以调用子类之上所有父类层级
- 如果父类中有无参的构造器，子类调用父类的构造器想当于在无参构造器中用super（）。 父类中无无参构造，子类中必须显示的构建一个构造来调用父类的有参构造上，并且方法必须写第一行。
- 简单类对象的实例化过程：
Person p = new Person(){};
**在JVM内存中**
/*
1. 在方法区加载Person.class
2. 在栈中申请空间，声明变量p
3. 在堆内存中开辟空间，分配地址
4. 堆内存中在对象空间中，对对象中的属性进行默认初始化，然后在类成员变量显示初始化。
5. 构造函数方法进栈，进行初始化。
6. 初始化后，将堆内存中的地址值赋给引用变量，构造方法出栈。
*/
子类对象的实例化过程：
Student stu = new Student();
/*
1.方法区加载Person.class，在Student.class。
2.在栈中申请空间，声明变量stu。
3.在堆内存中开辟空间，分配内存。
4.在对象空间中对对象中的属性包括父类的属性进行初始化。
5.子类构造函数方法进栈。
6.显示初始化父类的属性。
7.父类构造方法进栈，执行完毕出栈。
8.显示初始化子类的属性
9.初始化完毕后，将堆内存的地址值赋给引用变量。子类构造方法出栈。
*/
1.3 面向对象三大特征之多态
- 方法的重载（本类中的同名方法，体现相同名称方法实现不同的逻辑）和重写(子类对父类方法的覆盖子类可以使用和父类相同的方法名，覆盖掉父类的逻辑。父类的方法，想修改逻辑，但是有别的代码在调用父类的方法，可以考虑用子类继承父类，重写父类的方法)。
- **对象的多态性：**可以直接应用在抽象类和接口上。
- Java引用变量有两个类型：编译时类型和运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。 若编译时类型和运行时类型不一致，就出现多态。
- 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型。
- 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。（属性是由编译时确定的。）
- Person e = new Student（）；方法的调用是在运行时确定的，所以调用Student类的方法。–动态绑定 （虚拟方法调用）必须存在方法的重写中。
- 方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法。
- instanceof操作符：
x instanceof A：检验x是否为类a的对象返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
x属于类a的子类b，值也为true。 - Object类：
Object类是左右Java类的父类。
Object类中的主要方法：
Object（）构造
boolean equals(Object obj) 对象比较
int hashCode() 取得Hash码
String toString() 引用的对象所在的内存地址。
2.java类
2.1 类的成员之变量
- 成员变量
- 实例变量 ：没有static修饰，只有在类实例化成对象之后才能使用。
- 类变量：static修饰不需要类实例化成对象，就可以使用，只用就是用类名加属性使用。
- 局部变量（方法内的变量）
- 形参：方法签名中定义的变量
- 方法局部变量：方法中定义。
- 代码块局部变量：在代码块中定义。
2.2 类的成员之方法
- 方法的可变参数传递： Java特有的“…”的方式传递可变个数的参数，在使用时与数组的使用方式相同。
数组传递的方式没有参数时需要空数组。如果一个方法有多个形参，可变的参数（…）一定要放在所有的参数最后。 - 方法的参数传递： Java里的方法的参数传递方式只有一种：值传递。即将实际参数值的副本传入方法内，而参数本身不受影响。
- 类的构造方法：
- 定义了显示的构造器，系统不再提供默认构造器。
- 一个类可以创建多个重载的构造器。
- 父类的构造器不可被子类继承。
- 关键字 this：
- 在方法内部使用，即这个方法所属对象的引用。
- 它在构造器内部使用，表示该构造器正在初始化的对象。
- 当方法内部需要使用改方法对象的时候使用this。
- 访问本类中的属性，如果本类中没有此属性则从父类中继续查找。
- this可以作为一个类中，构造器相互调用的特殊格式。
public Person(){} public Person(String name){ this.();// =Person(); this.name = name; }- 使用 this() 必须放在构造器的首行，使用this 调用本类中的其他的构造器，保证至少有一个构造器是不用this的。即不能出现构造器自己调用自己。
- main方法
public static void main(String[] args){}
/*
由于java虚拟机需要调用类的main方法，所以访问权限是public。java虚拟机在main()方法是不必创建对象，所以方法必须是static，
该方法接受一个String类型的数组参数，该数组保存执行java命令时传递给所运行类的参数。
*/
2.3 类的访问机制
- 在一个类中的访问机制，类中的方法可以直接访问类中的成员变量。例外：在stactic方法中
访问非static的成员变量，编译不通过。 - 在不同类中的访问机制：先创建要访问的类的对象，再用对象访问类中定义的成员。
2.4 对象
- 匿名对象
Student s = new.Student;
s.showInfo();// 相当于new Student().showInfo(); 只为了调用一次方法，经常用匿名对象作为实参传递给一个方法调用。
-
对象类型转换
基本数据类型转换：
自动类型转换：小的数据类型可以自动转换成大的数据类型。
强制类型转换：大的数据类型强制转换成小的数据类型。int a = （int）10l； -
对Java对象的强制类型转换成为造型
从子类到父类的类型转换可以自动进行。
从父类到子类的类型转换必须通过造型（强制类型转换）实现。
无继承关系的引用类型间的转换是非法的。 -
= =操作符 与equals
当= =操作符用作引用类型的时候，只有当指向同一个对象时，= =才返回true。
基本类型比较值:只要两个变量的值相等，即为true。
用“= =”进行比较时，符号两边的数据类型必须兼容（可自动转换的基本数据类型除外），否则编译出错。
equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。
只能比较引用类型，其作用与”= =“相同，比较是否指向同一个对象。
特例：当用equals()方法进行比较时，对类File、String、Date及包装类(Wrapper Class)来说，是比较类型及内容而不考虑是否指向同一个对象。
对于对象来说
特殊的类，如String、File、Date，使用= =比较的是对象（对象的地址）
equals比较的是内容
除了特殊类之外的其他普通的类的对象，==和equals比较的都是对象(对象的内存地址)
如果你想改变一个类的equals，不想用equals来比较对象的内存地址，就需要重写equals。 -
String对象的创建：
- 字面量创建String对象：
String s1 = “abc”;堆中的字符串常量池添加“abc”对象，返回引用地址给s1对象。
String s2 = “abc”;通过equals()方法判断常量池中已有值为abc的对象，返回相同的引用。
此时判断s1 == s2，返回值为true。因为此时的内存地址相同。 - new创建String对象：
String s3 = new String(“def”);在常量池中添加“def”对象，在堆中创建值为“def”的对象s3，返回指向堆中s3的引用。
String s4 = new String（“def”）;常量池此时已有def对象，不做处理，在堆中创建值为”def"的对象s4，返回指向堆中s4的引用。
字面量方法要比new省内存。
String s5 = “x”+“y”;经过JVM优化，直接在常量池里添加“xy”对象。
String s6 = new String(“1”)+new String(“1”)+new String(“2”);通过StringBuilder实现，在常量池中添加“1”和“2”两个对象，此时不会在堆中创建三个对象，而是直接生成“112”对象，引用地址给s6。
- 字面量创建String对象：
-
包装类：
针对八种基本定义相应的引用类型-包装类（封装类）
有了类的特点，就可以调用类中的方法。
boolean(Boolean) byte(Byte) short(Short) int(integer) long(Long) char(Character) float(Float) double(Double)基本数据类型包装成包装类的实例 --装箱
通过包装类的构造器实现：
int i = 500；Integer t =new integer(i);
通过字符串参数构造包装类对象
Float f = new Float(“4.56”);获得包装类对象中包装的基本类型变量 --拆箱
调用包装类的.xxxValue()方法。
boolean b =bObj.booleanValue();
JDK1.5后可以自动装箱拆箱。
Integer i = 500;自动装箱。
int i1 = i;自动拆箱
- static：
static修饰，类变量不用实例化，直接类名.属性名就可以使用，是类的一部分，被所有这个类的实例化对象所共享，也可以叫静态变量。
实例变量，只有实例化之后才能使用，属于实例化对象的一部分，不能共用。
在设计类时，分析哪些类属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。
被修饰后的成员具备以下特点：- 随着类的加载而加载。
- 优先于对象存在。
- 修饰的成员，被所有对象所共享。
- 访问权限允许时，可不创建对象，直接被类调用。
- 类方法做工具类用的最多。在static方法内部只能访问类的static属性，不能访问类的非static属性。因为不需要实例就可以访问static方法，因此static方法内部不能有this，也不能有super。
2.5 设计模式
- 单例设计模式： 对某个类只能存在一个对象实例。使用情况，例如实例化对象的创建要消耗大量的时间资源，或者频频new新的对象没有必要。饿汉式、懒汉式。new的时间不同。
- 饿汉式单例模式
/*
是多线程安全的。
这种方式较为常用，但容易产生垃圾对象。
优点：没有加锁，执行效率提高。
缺点：类加载时就初始化，浪费内存
*/
public class Single{
private Single(){}//构造函数
private static Single single = new Single();//饿汉式单例模式，类加载时就把单例初始化好了。
public static Single getInstance(){
return single;
}
}
- 懒汉式单例模式
/*
不是多线程安全的。
*/
public class Single {
private Single(){}
private static Single single = null;//不初始化单例
public static Single getInstance(){
if(single == null){
single = new Single();
}
return single;
}
}
- 工厂方法模式结构
- 抽象产品：定义了产品的规范，描述产品的主要特性和功能。
- 具体产品：实现抽象产品角色所定义的接口，由具体工厂来创建，它与具体工厂之间一一对应。
- 抽象工厂：提供创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
- 具体工厂：实现了抽象工厂中的抽象方法，完成具体产品的创建。
public interface Rider {
void showInfo();
}//抽象产品接口，提供了一个查看信息的功能
/*
具体产品，实现抽象产品的showInfo()方法。
*/
class kabuto implements Rider {
@Override
public void showInfo() {
System.out.println("这是kabuto");
}
}
class faiz implements Rider {
@Override
public void showInfo() {
System.out.println("这是faiz");
}
}
class DIN_O implements Rider {
@Override
public void showInfo() {
System.out.println("这是电王");
}
}
/*
抽象工厂，提供创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
*/
public interface RiderFactory {
Rider productRider();
}
/*
具体工厂，实现抽象工厂中的抽象方法。
*/
class kabutoFactory implements RiderFactory{
@Override
public Rider productRider() {
System.out.println("生产kabuto");
return new kabuto();
}
}
class faizFactory implements RiderFactory{
@Override
public Rider productRider() {
System.out.println("生产faiz");
return new faiz();
}
}
class din_OFactory implements RiderFactory{
@Override
public Rider productRider() {
System.out.println("生产电王");
return new DIN_O();
}
}
737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
