Java封装、继承顿、多态

封装、继承顿、多态

Static

Static是什么  能做什么

            static 是一个修饰符关键字 , 用来区别静态和成员属性

            static修饰符
                1 类体中使用 static 修饰的变量  是静态变量
                2 类体中使用 static 修饰的方法 是静态方法
                3 类体中使用 static 修饰的语句块 是静态语句块

怎么用

//静态变量
static int age = 18;

//静态方法
public static void m1(){}

//静态语句块
//没有名字,自动执行(最先执行),并且只执行一次,不能手动调用(没有名字)
//因为最先执行,并且只执行一次,所以适合做程序的初始化工作
static{
    System.out.println("静态语句块1");
}
static{
    System.out.println("静态语句块2");
}
public static void main(String[] args){
    System.out.println("main方法");
}

            静态变量和静态语句块  都是类加载阶段进行初始化和执行 , 而main方法是在加载完之后 , 进入运行时才会执行
                所以 静态变量和静态语句块的优先级 大于 main方法
           
            什么时候类加载?
                访问一个类的静态属性的时候 , 会把该类载入内存中 

public class Test1{
    static {
        System.out.println("Test1静态语句块");
    }
    static int age = 222222;
}

public static void main(String[] args){
    System.out.printlln("main方法");
    System.out.printlln(i2);
    System.out.printlln(Test1.age);
}

实例化语句块

public class Static_02{
    //实例语句块 等同于成员方法 只是没有名字
    //因为成员属性需要依赖于对象
    //所以 创建对象之后 立刻执行 并且创建一次对象就执行一次
    {
        System.out.println("实例语句块1");
    }
    {
        System.out.println("实例语句块2");
    }
    public static void main(String[] args){
        new Static_02();
        new Static_02();
    }
}

静态和成员

           当对象拥有相同属性和值   可以使用静态变量 
           当所有对象拥有相同属性和不同的值(可以相同)  使用成员变量
           当一个方法中有静态的引用(使用了成员属性)  需要使用成员方法  
           当一个方法中没有成员属性的引用  可以使用静态方法

封装

           封装是把对象的所有组成部分组合在一起   其使用访问控制符将类的数据隐藏起来 , 以此达到控制用户对类的修改和访问数据的程度
       作用 :
           适当的封装可以让代码更容易理解和维护 , 也加强了代码的安全性

 软件包机制

   package : 设置的是编译之后的class文件的保存目录 , 和源文件没有关系
   软件包机制 : 
           1 为了解决命名冲突问题
           2 package语句只能出现在java源文件的第一行
           3 通常采用公司域名倒叙的方式
                   域名倒叙.项目名.模块名
                   com.tledu.oa.system
                   com.tledu.oa.model
                   com.tledu.oa.controller
           4 完整的类名是 带有包名的
                   带有包名的类 
                           编译        
                               javac -d 生成路径  源文件
                               javac -d ./ -encoding utf-8 A.java
                           运行
                               java com.teldu.zrz.A

package package1;

//引入当前类中需要的其他类
import package1.com.A;
//包名.* 是引入当前包下所有类
import java.util.*;
//java.lang.* 下的类 是核心类,不需要导入

public class package_02 {
	public static void main(String[] args) {
		String s = "";
		package1.com.A a = new package1.com.A();
		A a1 = new A();
		Date d = new Date();
		Arrays.asList(null);
	}
}

package package1;

//静态导入,在访问这个类的静态属性的时候,可以直接写名字,不需要加类名前缀
import package1.User;

//注意 : 编码的时候,按空格和回车 会自动导包,特别注意,别导错
public class package_03 {
	static int a;
	static int b;
	public static void main(String[] args) {
		System.out.println(User.a);
		System.out.println(User.b);
		System.out.println(a);
		System.out.println(b);
		// Date date = new Date();
	}
}

权限控制

继承

概述

           从已有类中派生出新的类,新的类能有用已有类的属性和行为,并且还可以扩展新的属性和行为
           目的 : 代码重用
               1 java中只支持单继承,一个类只能有一个父类,但是一个类可以拥有多个子类
               2 private修饰的属性,不能继承
               3 使用extends关键字表示
                   class 子类名 extends 父类名{}
            
               4 如果一个类没有显示继承另一个类,则该类默认继承 Object (java.lang.Object)
                  Object是java提供的根类(祖宗)
                  任何类都直接或者间接继承 Object

使用

super

概述

           Super保存了父类型特征

能做什么

           1 区分子类和父类同名的变量和方法
           2 super(...) 只能用在子类构造方法第一行,用来调用父类构造方法
                       this(...) 也是必须在构造方法第一行,所以 this()和super() 不能同时出现
                       如果构造方法中没有this() 也没有 super()  则 构造方法第一行默认有super() 调用父类无参构造

package super1;

public class Sub extends Sup{
	public Sub(){
		// 如果没有this(...)和super(...) 则默认有super() 调用父类无参构造
		super(2);
		System.out.println("子类构造方法");
	}
	int a = 20;

	public void m1() {
		System.out.println("子类的m1");
	}
	public void print() {
		System.out.println(a);
		System.out.println(super.a);
		m1();
		super.m1();
	}
}

构造方法私有化

package super1;

public class super_03 {
	public static void main(String[] args) {
		A a = new A();
		// B b = new B();
	}
}

class A extends B {
	A() {
		// 私有化构造方法之后,该类不能被继承,因为子类构造方法中需要用到super() 去调用父类构造
		super();
	}
}

class B {
	// private B(){
	B() {

	}
}

override

概述

   覆写,重写,覆盖

   继承了父类的方法,并 对其方法进行重写

  什么时候需要重写?
          当父类方法功能无法满足子类需求的时候,需要对父类方法,进行重写
  
      重写条件 : 
          1 有继承关系的体系中
          2 方法名相同,参数列表相同,返回值相同
          3 不能比原方法拥有更低的访问权限(大于等于的关系)
          4 不能比原方法拥有更宽泛的异常
          5 覆写,特指成员方法,和静态变量,静态方法,成员变量无关
  
  Override和Overload区别
          1 分别说出是什么
          2 分别说出是干什么的

public class Override_01 {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.move();
		cat.m1();
		
		Animal a = new Cat();
		a.move();
		a.m1();
	}
}
class Animal{
	public void move(){
		System.out.println("动物在移动");
	}
	public static void m1(){
		System.out.println("父类静态方法");
	}
}
class Cat extends Animal{
	// Override注解 是编译时注解,运行时就没有了,功能是在编译时检查,该方法是否是覆写的方法,防止写错
	@Override
	public void move() {
		System.out.println("猫走猫步");
	}
	public static void m1(){
		System.out.println("子类静态方法");
	}
}

Final

概述

  final : 修饰符,表示最终的
  
          final修饰的类,不能被继承
          final修饰的成员方法, 不能被覆写
          fianl修饰的变量,没有默认值,并且不能二次赋值,必须显式赋值
  
          常量 : 一般使用 public static final修饰 psf,整个程序生命周期 值不能被更改
              常量建议命名全部大写

修饰引用类型

package Final1;

//final修饰的引用类型
public class Final_02 {
	public static void main(String[] args) {
		final User user = new User("admin");
		// 可以更改,因为user使用final,并不是username,所以和堆内存对象没有关系
		// 只是user变量的值不能更改而已
		user.username = "root";
		// 报错,因为final修饰
		// user = null;
		System.out.println(user.username);
	}
}
class User{
	String username;
	public User(String username) {
		this.username = username;
	}
}