java学习记录5

面向对象的特征：


1.封装：面向用户更简单，面向属性更安全
 private


class L 
{
private String name;
private int age;
private int mess;
private boolean state;
private float[] num;


public void setNum(float[] num){ //数组封装
this.num=num;
}
public float[] getNum(){
return num;
}
public float getNum(int index){
return num[index];
}
public void setNum(int index,float numb){
this.num[index]=numb;
}




public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}

public void setAge(int age){

if(age<0)return;
this.age=age;
}
public int getAge(){
if(age>25)return age - 2;
return age;
}


public void setMess(int mess){
if(mess<6){
this.mess=mess;}
}
public int getMess(){
return mess;
}


public void setState(boolean state){
this.state=state;
}
public boolean isState(){
return state;
}


public L(String name,int age,int mess,boolean state){
this.name=name;
this.age=age;
this.mess=mess;
this.state=state;
System.out.println("java");
}


public static void main(String[] args) 
{
L l=new L("12",21,4,true);
l.setAge(26);
l.setAge(-2);
l.setMess(8);
l.setName("lilin");
l.setState(false);
System.out.println("Hello World!");
System.out.println(l.name);
System.out.println(l.age);
System.out.println(l.mess);
System.out.println(l.state);


}
}






2.继承：代码的高效率复用，也可以说是产品的扩展和升级
继承等于拥有，但对私有不可访问


父类   子类
超类   派生类
基类
     关键字：extends


子类继承父类的一切。
先new出父类对象，后new出子类对象


super();//超类对象；有（）事选择父类的某一个构造器，无（）是父类对象
子类的构造的过程中必须调用其基类的构造方法。


子类可以在自己的构造方法中使用super()调用父类的构造方法。

使用this()调用本类另外的构造方法
如果用super,必须写在方法的第一句




public class Aaaa{
public Aaaa(int i){

i=i*2; //最好一个类一个文件
System.out.println(i);
}
public Aaaa(String i){

System.out.println(i);
}
public Aaaa(){
System.out.println("lilin");
}
}


public class Ll extends Aaaa{
public Ll(){
super(1);     //超类对象
}
public Ll(String i){
super(i);
System.out.println("llll");
}
public Ll(int i){
super(i);
}
}


public class Test12{
public static void main(String[] args){
//Ll l=new Ll("123"); //调方法时，子类有调子类，子类无调父类
Ll l=new Ll();
//Ll l=new Ll(12);


}
}


方法重写：子类写一个与父类同名的方法
在子类中可以根据需要对从基类中继承来的方法进行重写。


 
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。


 
重写方法不能使用比被重写方法更严格的访问权限。（由于多态）
super.method();


类上加final，不允许继承   final class A{ }
方法不可被重写 public final void method(){ }
 
Object   祖先类
Class    管理类


3.多态：子类演变为父类
子转父，自动转  A b=new B();
父转子，强制转


万事万物皆功能


面向父类编程