javaSE基础学习03(面向对象)

最新推荐文章于 2024-04-18 23:45:00 发布

~哦~豁~

最新推荐文章于 2024-04-18 23:45:00 发布

阅读量98

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/ziao890122/article/details/108404856

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

javaSE基础学习03

面向对象

面向过程和面向对象的区别
1. 面向对象是将现实世界分割成不同的单元，每个单元就是一个对象，对象与对象之间协作起来完成一个功能。
2. C语言面向过程、C++半面向对象、Java面向对象。
3. 面向过程指的是具体做一件事的过程
类和对象的概念
1. 类是一种事物的定义，事物具有哪些特征，但并没有具体值（类比excel文件（cat文件：有颜色、年龄、主人等列名信息，但没有具体数据））
2. 对象是类的实例化，一个类可以创造出多个对象（（类比excel文件（cat文件：颜色黄色、年龄 3岁、主人 Tom）））
3. 类的组成包含：属性+方法

类的定义

类定义的语法结构：【修饰符列表】 class 类名{}
1. 类的权限控制只能用默认权限和public权限
2. 创建类文件举例
```
//定义明星类Star

public class Star{
	// 姓名
	String name;
	// 身高
	double height;
	// 性别
	boolean sex;
	// 住址
	String address;
}
```
1. name、height、sex、address都是变量，在类中被称为属性，并且这些变量都属于成员变量中的实例变量，所谓的实例变量表示对象级别的变量，要访问这些变量必须先完成对象的创建。对象有了，通过对象才可以访问这些变量。
2. 定义类时，按照编程风格属性统一都改为私有，通过提供的方法操作属性
3. 对属性操作的方法 set变量名，get变量名，可在IDEA用快捷方式生成，注意 set方法无返回值，get方法返回和变量名同类型的数据类型。
4. toString() 方法，在类中定义该方法，作用是打印类中的属性和值，调用时可默认不写 .String(), 直接sout 创建的对象即可。

匿名类

实例内部类（了解）

 创建实例内部类，外部类的实例必须已经创建

 实例内部类会持有外部类的引用

 实例内部不能定义 static 成员，只能定义实例成员

public class InnerClassTest01 {
	private int a;
	private int b;
InnerClassTest01(int a, int b) {
	this.a = a;
	this.b = b;
}
//内部类可以使用 private 和 protected 修饰
private class Inner1 {
	int i1 = 0;
	int i2 = 1;
	int i3 = a;
	int i4 = b;
    //实例内部类不能采用 static 声明
	//static int i5 = 20;
}
public static void main(String[] args) {
	InnerClassTest01.Inner1 inner1 = new InnerClassTest01(100, 200).new Inner1();
	System.out.println(inner1.i1);
	System.out.println(inner1.i2);
	System.out.println(inner1.i3);
	System.out.println(inner1.i4);
	} 
}

静态内部类（了解）

 静态内部类不会持有外部的类的引用，创建时可以不用创建外部类

 静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

实例代码

public class InnerClassTest02 {
	static int a = 200;
	int b = 300;
static class Inner2 {
//在静态内部类中可以定义实例变量
	int i1 = 10;
	int i2 = 20;
    //可以定义静态变量
	static int i3 = 100;
	//可以直接使用外部类的静态变量
	static int i4 = a;
	//不能直接引用外部类的实例变量
	//int i5 = b;
	//采用外部类的引用可以取得成员变量的值
	int i5 = new InnerClassTest02().b;
}
public static void main(String[] args) {
	InnerClassTest02.Inner2 inner = new InnerClassTest02.Inner2();
	System.out.println(inner.i1);
	} 
}

局部内部类（了解）

局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样局部内部类和实例内部类一致，不能包含静态成员

实例代码

public class InnerClassTest03 {
	private int a = 100;
    //局部变量，在内部类中使用必须采用 final 修饰
	public void method1(final int temp) {
		class Inner3 {
		int i1 = 10;
		//可以访问外部类的成员变量
		int i2 = a;
		int i3 = temp;
		} 
		//使用内部类
	Inner3 inner3 = new Inner3();
	System.out.println(inner3.i1);
	System.out.println(inner3.i3);
}
public static void main(String[] args) {
	InnerClassTest03 innerClassTest03 = new InnerClassTest03();
	innerClassTest03.method1(300);
} }

匿名内部类（掌握）

是一种特殊的内部类，该类没有名字

实例代码

public class InnerClassTest04 {
    public static void main(String[] args) {
		MyInterface myInterface = new MyInterface(){
            //直接使用匿名内部类重写接口方法，并创建对象
        	public void add() {
				System.out.println("-------add------");
			}
        };
		myInterface.add();
        
	} 
}
interface MyInterface {
public void add();
}

以上代码通过lambada表达式简化

public class InnerClassTest04 {
    public static void main(String[] args) {
		MyInterface myInterface = ()->{System.out.println("-------add------");};
		myInterface.add();
        
	} 
}
interface MyInterface {
public void add();
}

对象的创建和使用
1. 创建对象：类名 + 引用对象 = new 类名（【构造方法参数列表】）；
2. 对象在类加载时，就会赋默认值，而非创建对象时赋值
3. 内存结构分析
  1. JVM的内存模型中包括最基本的三块空间：栈、堆、方法区。
  2. 一个线程一个栈，10个线程则10个栈。堆只有1个。方法区只有1个
  3. 栈内存中存储局部变量；堆中存储对象以及对象相关的实例变量；方法区中存储类信息、静态变量。
  4. 垃圾回收器主要针对堆内存。
  5. 对象是堆中创建的，引用是将堆中创建的对象的地址保存到引用。
4. 访问对象的属性
  1. 访问“实例变量/属性”必须先创建对象，然后通过“引用.”的方式访问，直接使用“类名.”是无法访问的。
  2. 实例变量没有手动赋值的时候，系统会默认赋值。
  3. 访问对象的属性包括读取和修改。
5. 对象的构造方法
  1. 构造方法格式：修饰符类名（属性列表）{}
  2. 构造方法特征：
    1. 没有返回，不写任何返回值类型，包括void
    2. 构造方法名和类名一致
    3. 修饰符可用 public 、private、protected
    4. 构造方法，默认自带了一个，如果显式地写了构造方法（不管有无参数），则默认构造方法失效
  3. 构造方法的重载/overload
    1. 与普通方法的重载基本一致
    2. 参数个数不一致
    3. 参数类型不一致
    4. 参数个数一致，参数类型顺序不一致
面向对象三大特征
1. 封装
2. 继承
3. 多态
this和super
1. this 代表当前对象，哪个对象调用属性和方法，this就代表谁
2. this大部分情况都是可以省略的，只有在区分全局变量和局部变量的时候不能省略
3. this();可调用当前类的构造方法。但是只能出现在第一行，且必须出现在构造方法的方法体中
4. 构造方法里可以调用普通方法，普通方法不能调用构造方法
5. super使用的前提是必须有继承关系
6. super点的方式可调用继承的父类的属性或者方法
7. super()；默认出现在子类的构造方法里，具体写了super()，则必须写在构造体的第一行，所以this()和super()不能同时存在一个构造方法中
8. super大部分情况也是可以省略，但是当子类和父类存在相同的属性名或者方法名时，不能省略
9. 子类的构造方法都会调用父类无参的构造方法，但并没有创建一个父类的对象，只是先构造了子类继承父类的属性和方法

修饰符的权限范围方法的重写

权限修饰符的访问范围	不同包	子类不同包	同包	同类
public	可以	可以	可以	可以
protected	不可以	可以	可以	可以
默认不写	不可以	不可以	可以	可以
private	不可以	不可以	不可以	可以

方法的重写

前置条件：类之间必须有继承关系
重写要求：类之间必须有返回值类型、方法名、参数列表都一样的方法
重写的方法可以修饰符不一样，但是子类的方法权限必须大于等于父类的方法权限
重写的注释是 @override

子类对象方法重写，即使使用super调用父类方法中调用到了子类的重写方法，仍旧会去找子类重写方法执行

public class Base {
	public void m1(){
		System.out.println("A");
		m2();
	}
	public void m2(){
		System.out.println("B");
	}

}


public class Sun  extends Base{
	public void m1(){
		super.m1();
		System.out.println("C");
	}

	public void m2(){
		spuer.m2();
		System.out.println("D");
		}
}
//主方法中执行这两句
Sun s= new Sun();

s.m1();



//输出顺序为 A B DC

向上转型和向下转型
1. 前提条件：存在继承关系
2. 继承链下面的对象可以说成是上面的对象，就是向上转型，如猫是动物
```
Animal a = new Cat();
```
  使用动物类接收了猫的对象，就是向上转型
3. 向下转型
  1. 向下转型必须先有一步向上转型，否则会报类型转换错误（原因：没有向上转型的步骤，则代表没有需要转换的这个对象，就会报错）
  2. 由于向下转型可能会引起异常，需要使用 instanceof关键字进行判断，规范用法
```
Animal  a  = new Cat();

if (a instanceof Cat){

	Cat c = (Cat) a;

}
```
抽象类和抽象方法
1. 产生原因：类之间存在继承关系，并且子类都将方法进行重写了，创建子类对象，调用方法时，总是调用不到父类的方法体，则父类的方法可以声明为静态方法
2. 关键词 abstract
  1. 写在返回值前面，将方法抽象化
  2. 抽象方法格式： public abstract 返回值方法名();
  3. 声明了抽象方法的类必须要是抽象类
3. 抽象类中不一定有抽象方法
4. 抽象类不能直接创建对象，需要用子类的对象表示
接口 interface
1. 实现某种功能的事物，接口注重实现功能
2. java接口中的方法都是抽象方法
3. 接口方法写法：返回值方法名();
4. 接口是抽象的事物，需要通过类来实现，关键字 implements
5. 类实现接口需要实现接口中的所有方法
6. 类可以一次实现多个接口
7. 类是先继承后实现 extends关键词在前，implements在后
8. 接口中只有常量+方法
9. 接口修饰常量的 public static final 可以省略不写，默认不写就是 public static final
10. 接口中修饰方法的 public abstract 可以省略不写，接口默认方法不写修饰符就是用 public abstract 修饰
11. 接口中方法不能有方法体，但是在jdk1.8 之后，可以写 default修饰的方法和 static修饰的方法
接口和类的关系
1. 类实现接口（可以多实现）
2. 接口继承接口（可以多继承）
3. 类继承类（单继承）
4. 接口–》类（没有关系）
static 和 final
1. static
  1. 静态的，需要优先加载，使用类的时候会优先加载static修饰的内容
  2. 不可修饰：类（因为类是惰加载）、get.set方法（因为get.set是实例属性赋值，和类有关）、局部变量（修饰局部变量类点不到，冲突）、构造方法（构造方法用来创建对象，冲突）、抽象方法（抽象方法等着子类实现，修饰之后不能重写，冲突）
  3. 可修饰：全局变量、普通方法
    1. static修饰的全局变量叫做静态变量
    2. 通过类点变量的方式调用,也可通过类对象调用。但是不建议
    3. static修饰的普通方法叫做静态方法,通过类点方法进行调用
  4. static{}
    1. 静态代码块,在类被使用时加载且只加载一次
  5. {}
    1. 构造语句块,在构造方法被执行前加载
    2. 执行一次构造方法就执行一次构造语句块
  6. 静态代码块也是从上往下执行，所以不能先使用静态属性，再在下面定义静态属性
2. final
  1. 最终的，最后的，修饰的类或者方法或者属性，具有赋值一次之后不可修改的特性
  2. final可修饰：
    1. 属性
      1. 修饰属性时赋值后不能修改
      2. 可在定义的同时赋上初值
      3. 可在构造方法赋上初值
      4. 可在构造代码块赋上初值
    2. 类
      1. 类被修饰之后就没有子类了。String类，Math类等都是被final修饰的
    3. get set 方法
      1. 可修饰，但不这么使用，因为子类使用不了这个方法
    4. 普通方法
      1. 修饰之后方法不能被重写
    5. 引用对象
      1. 修饰后该引用对象不能再指向其它对象,但引用对象内部的属性还是可以修改
3. static final联合使用
  1. 修饰的属性就是一个常量
    1. 可在定义时且赋值
    2. 可在静态代码块中赋值
    3. 常量的书写规范是全部都为大写字母
enum
1. 枚举，将所有可能的情况都列举出来
2. 定义：如 public enum Test{}
3. 枚举中直接定义常量，枚举类中的元素，都可以使用类名点的方式直接调用

~哦~豁~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaSE基础学习03(面向对象)

javaSE基础学习03面向对象面向过程和面向对象的区别面向对象是将现实世界分割成不同的单元，每个单元就是一个对象，对象与对象之间协作起来完成一个功能。C语言面向过程、C++半面向对象、Java面向对象。面向过程指的是具体做一件事的过程类和对象的概念类是一种事物的定义，事物具有哪些特征，但并没有具体值（类比excel文件（cat文件：有颜色、年龄、主人等列名信息，但没有具体数据））对象是类的实例化，一个类可以创造出多个对象（（类比excel文件（cat文
复制链接

扫一扫