[Backgammon] Java基础学习入门（封装，多态，抽象类，final修饰符）

1.封装

使用不同的四种不同的修饰符封装起来，修饰符是不同的访问控制权限

• 用于定义访问权限修饰符的关键字

私有的，本类可见	不同的包，子类可见	同包下其他类可以见到	所有可见
private	p’rotected	默认的（不写）	public

1. 属性的封装

   package com.mage.tset;
   
   public class Tset {
    
   	private int s;
   	public int t;
   	
   }
   class Dema{
   	public static void main(String[] args) {
   		Tset ch=new Tset();
   		ch.t=10;//public修饰的属性可以正常使用
   		ch.s=10;//private修饰的属性报错
   	}
   }
   

   • 当属性访问权限降低之后，如果访问以及修改当前属性，需要通过类中内部定义的方法实现。

2. 构造器的封装

   package com.mage.tset;
   
   public class Tset {
    
   	private Tset(){//构造器私有
   }
   	public static Tset setTset(){//应提供静态方法方便调用
   		return new Tset();
   	}
   }
   public class Tset02{
   	public static void main(String[] args) {
   		Tset cg = Tset.setTset(); //静态方法直接类名调用方法
   		
   	}
   }
   
   

   • 构造器封装之后无法产生对象，但是在一定程度上是有必要的

3. 方法的封装

public class Arrays {
private int[] datas;
private int index;//维护了添加数据的位置
public Arrays() {
// 给属性赋值
datas = new int[4];
index = 0;
} /
/往Arrays对象中添加元素
public void add(int value) {
if(index>=datas.length) {
resize();
} d
atas[index] = value;
index++;
} p
rivate void resize() {
//声明一个新的数组
int[] newArrs = new int[datas.length*2];
//复制
for(int i = 0;i<index;i++) {
newArrs[i] = datas[i];
} d
atas = newArrs;
} p
ublic String toString() {
String prefix = "arrs[";
String content = "";
for(int i = 0;i<index;i++) {
content += datas[i]+"\t";
} S
tring sffix = "]";
String ret = prefix+content+sffix+""+datas.length;
return ret;
} p
ublic int getLength() {
return index;
}
}

• 方法封装就是将一些核心的业务隐藏起来，让内部更加安全。

  2.1 多态

  多态：多种形态

  如何编写多态

  public class Tset4 {//父类
  	public void test(){//父类方法
  		
  	}
  }
  
  
  public class Tset5 extends Tset4{//继承父类
  	@Override//判断是否为重写方法，@Override不报错则是重写方法
  	public void test(){//子类重写父类方法
  		System.out.println("重写方法");
  	}
  }
  
  public class Tset6 {
  	public static void main(String[] args) {
  		Tset4 ts= new Tset5();//父类变量指向子类对象
  		ts.test();调用重写方法
            
  	}
  	
  	
  }
  

  多态产生的必要条件

  • 一定要发生父子关系。exetnds
  • 子类一定要重写父类的方法。
  • 父类变量指向子类对象
  • 父类变量调用重写方法。
  • 编译看左边，运行看右边

  3.1抽象类

  １.抽象类的定义

ublic abstract class Animal {}
/*修饰符 abstract class 类名*/

在定义类的时候，加入abstract关键词来修饰类，此时该类是一个抽象类

2.抽象类中定义的内容详解

• 抽象类中可以定义和类中完全一样的内容（属性，方法，构造器）；
• 抽象类中的方法可以是抽象方法，也可以是非抽象方法。
• 抽象类就是通过abstract修饰的类，它的目的是用来被继承的
• 被abstract修饰的方法称之为抽象方法，抽象方法只要方法声明没有方法体。

//修饰符 abstract [void|返回值类型] 方法名称（参数列表）；
public avstract void m();

• 接口也可以定义抽象方法
• 抽象类中的抽象方法就是用来被重写的
• 抽象类中的构造器就是用来被子类调用的，抽象类无法实例化
• 当一个类继承了抽象类之后，需要重写抽象方法，而且需要查看整个继承链中是否存在其他抽象方法，如果有就必须要全部重写。

4.fial

1. 常量
   通过final修饰的变量称之为常量，常量在程序运行期间其值不可以发生改变。

public class Tset{
static int num=10;
 public static void main (String[] args){
 		System.out.println(num);
 		 num =11;//编译报错 ，final修饰的常量不允许改变
 		 }
 }




final修饰类
public final class Tset02{
}
public class Sub extends Tset02{//代码定义错误
}

• 通过final修饰的类是无法被继承的。称作太监类。
• finl修饰类的目的就是为了防止继承

final修饰方法

public class F{
	public final viod tset(){//final修饰的方法
	}
}
public class S extends F{
@Override//报错、无法重写方法
public void tset(){
}
}

• final修饰方法，子类无法重写，无法发生多态
• final修饰的方法就是为了防止重写的