java--面向对象总结

方法头
方法头一般由方法名、参数列表、返回类型、方法修饰符和方法抛出的异常五部分组成。
java中声明方法的语法如下：
[修饰符] 返回值类型 方法名(参数列表){             【方法头】
语句序列；（方法体 ）
}


访问修饰符
访问权限：private<default<protected<public 
public :公共的，只要在当前Java项目中，都可以访问
protected：受保护的，在同一个包中，都可以访问，子类可以访问父类成员变量（继承）
default：默认的，仅在同一个包中，可以访问。
private:私有的，仅在当前类下，可以访问


静态方法
用static关键字声明的方法叫做静态方法，在静态方法中，不可以使用非静态的成员
静态变量/方法的调用
在使用静态变量/方法时，可以通过类名访问，而无需实例化
package static1;


import org.junit.Test;


public class static1 {
public static int num=0;
public void addation(){
this.num++;
}
public static String change(String str,int flag){
if(flag==0){
return str.toUpperCase();//大写
}else if(flag==1){
return str.toLowerCase();//小写
}else{
return str;//原样返回
}
}
@Test
public void test(){
static1 count=new static1();
count.addation();
System.out.println(static1.num);
}
@Test
public void test1(){
String str=static1.change("fdsFDSGsf", 2);
System.out.println(str);
}
}




什么是封装？
1.定义：
封装从字面理解就是包装的意思，专业点就是信息隐藏，是指将数据及数据的操作封装在一起，使其构成一个不可分割的实体，数据被保存在实体的内部，尽可能的隐藏内部的细节，只保留一些对外的通道使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流。也就是说，用户是无法知道对象内部的细节，但是可以通过该对象对外提供的访问通道来访问该对象。
2.封装的特点：
把类的属性隐藏，提供公共方法对其访问
提高了代码的复用性
提高了代码的安全性




对象数组
定义：
类型为对象的数组，称之为对象数组
public class classroom {
@Test
public void test(){
student stu1=new student("t1", 89);
student stu2=new student("t2", 99);
student stu3=new student("t3", 100);

student[] arr={stu1,stu2,stu3};

student[] arr1=new student[3];
arr1[0]=stu1;
arr1[1]=stu2;
arr1[2]=stu3;

for(int i=0;i<arr.length;i++){
student stu=arr[i];
System.out.println("姓名："+stu.getName()+"分数："+stu.getScore());
}
System.out.println("!@#$%^&*");
for(student stu:arr){
System.out.println("姓名："+stu.getName()+"分数："+stu.getScore());
}

}




什么是继承？
Java中使用extends关键字实现类的加载机制称之为继承，子类自动拥有了基类（也叫父类，superclass）的所有非私有成员，即成员变量和成员方法
继承的好处是什么？
引入继承可以减少重复的代码量，提高代码和开发效率
继承中的成员访问限制是什么？
如果父类中变量定义成了private私有变量，则在子类中是不可以调用的，其只能在父类的方法中调用，子类和其他类都不可以。
   Java只支持单继承，不支持多继承，即：一个子类只能有一个基类（父类），但是一个基类可以有多个子类
   子类对象包含父类对象
   静态方法是不可以继承的




Super关键字
Super关键字，可以用来子类调用父类的成员用，它包括调用父类的public、protected修饰的变量方法。
使用Super关键字的注意事项
 调用父类的方法：super.父类的方法
 同时super也可以调用父类的构造方法，但是父类中构造方法用private修饰时，不能有子类去继承
 子类可以没有构造方法，他会自动调用父类的构造方法
 在子类中可以调用父类的构造方法，super必须放在子类构造方法的首句


/**
 * 多态：一个对象，多种状态的行为，称之为多态
 * 满足多态的条件：
 * 1.要有继承，子类继承父类
 * 2.要有向上转型，父类引用指向子类对象
 * 3.要有重写，子类重写父类的方法
 * @author Administrator
 *
 *对象转型：
 *1.向上转型：父类的引用指向子类对象（可以理解为指针。还可以把向上转型比喻成父类访问子类。父类有很大的权利）
 *2.向下转型：子类的引用指向父类对象，向下转型必须强制转换，向下转型必须基于向上转型（可以理解为指针。还可以把向下转型比喻成父类降级，但仍然有父类的功能。）
 */
/**
 * 多态：一个对象，多种状态的行为，称之为多态
 * 满足多态的条件：
 * 1.要有继承，子类继承父类
 * 2.要有向上转型，父类引用指向子类对象
 * 3.要有重写，子类重写父类的方法
 * @author Administrator
 *
 *对象转型：
 *1.向上转型：父类的引用指向子类对象（可以理解为指针。还可以把向上转型比喻成父类访问子类。父类有很大的权利）
 *2.向下转型：子类的引用指向父类对象，向下转型必须强制转换，向下转型必须基于向上转型（可以理解为指针。还可以把向下转型比喻成父类降级，但仍然有父类的功能。）
 */
public class Jtest {
@Test
public void test(){
Person per=new Chinese("张","三");
per.display();

Person per1=new Englishman("张","三");
per1.display();
}
}


**************************************************************************************


/* //案例1
@Test
public void test(){
Dog dog=new Dog("erha","black");
Animal ani=dog;//向上转型
ani.getName();

Dog dog1=(Dog) ani; //向下转型
System.out.println(dog1.getName());
System.out.println(dog1.getFurcolor());
}*/


/*@Test
public void test1(){
//向上转型
Animal ani1=new Dog("erdai","blue");
Animal ani2=new Cat("lili","black");
Animal ani3=new Cat("ruby","white");
match(ani1);
match(ani2);
match(ani3);
}
private void match(Animal ani){
if(ani instanceof Dog){
Dog d=(Dog) ani;  //向下转型
System.out.println("狗的毛色："+d.getFurcolor());
}else if(ani instanceof Cat){
Cat c=(Cat) ani;  //向下转型
System.out.println("猫的眼睛颜色："+c.getEyescolor());
}
}*/
方法的重载
   方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。方法的重载即：同名不同参
方法重载的补充说明
参数不同指的是参数的类型不同或是参数的个数不同
构造方法也可以重载




        方法的重写
  方法重写基于继承，子类继承父类，子类可以调用父类的方法，同时子类也可以重写父类中的方法，来实现和父类中不同的业务处理逻辑。重写要求子类中方法与父类中的方法名称仙童，参数相同，参数类型相同。当子类调用该方法时，基类中的方法则被覆盖。方法重写即：重写父类方法，同名也同参


/**
* 方法的”重写“
* 与父类方法名同名也同参数
* 1.方法的名称相同（speek）
* 2.方法参数的类型相同（void）
* 3.方法参数的数量相同
*/
/**
* 方法的【重载】
* 前提条件：在同一各类中
* 我的理解：可以不在同一个类，因为是继承关系。可以把重写的方法（函数）注释掉。直接写重载方法也可以。
* 1.同名   方法的名称相同（speek）， 2.不同参数
*/




1、什么是Object类
Object类是所有Java类的根基类
如果在类的声明中未使用extends关键字指明基类，则默认基类为Object类
public class Person {
}
等价于
public class Person extends Object {
}
2、toString方法
Object类中定义有 public String toString() 方法，其返回值是String类型，描述当前对象的所有信息
在进行String与其他类型数据的连接操作时（如：System.out.println("info：" + person);），将自动调用该对象的toString()方法
可以根据需求在用户自定义类型中重写toString方法
3、equals方法
Object类中定义有 public boolean equals(Object obj) 方法，提供判断定义对象是否相等的逻辑
Object的 equals 方法定义为：x.equals(y) 当x和y是同一个对象的引用时返回true否则返回false
JavaSDK提供的一些类，如String，Date等，重写了Object类的equals方法，调用这些类的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回true否则返回false
可以根据需要，在用户自定义类型中重写equals方法


/**
* 接口：在java中，接口的作用是定义标准
* 特点：
* 1.接口中所有的方法都是共有的抽象方法
* 2.接口中所有的量都是共有的静态常量
*/
public abstract void theft();
//void theft();
public static final int suo=3;
//int suo=3;


抽象类和接口的区别：
用abstract关键字、interface关键字


接口是抽象类的特殊版本。接口里的方法必须都为抽象的，而抽象类里可以为抽象的也可以有其他形式的存在。


抽象类中可以存在非抽象方法。
实现抽象类里的方法时，可以实现所有方法，也可以实现部分方法。
抽象类里可以有私有的方法和私有的成员变量。
一个类只能继承一个抽象类，java只支持单继承


接口中的方法全部被修饰为公共的抽象方法。
接口里的方法都被修饰为public abstract类型的。
接口里的变量都被修饰为public static final类型的。
一个类可以实现一个接口，也可以实现多个接口。
接口里的方法必须全部实现


Usb mouse=new keymouse();//通过接口的实现类来实例化接口
mouse.work();
Usb key=new Usbkeyboard();//通过接口的实现类来实例化接口
key.work();

抽象类：
package Abstract2;


public abstract class Motovercal {
/**
* 抽象类
* 1.如果在程序设计过程中，定义了某个方法不需要该类来实现，
* 需要子类来重写，那么该方法应该定义为抽象方法，通过abstract关键字进行修饰
* 2.如果某各类中定义了抽象方法，那么该类务必定义为抽象类。
* 3.抽象方法只需要定义，不需要实现，谁继承，谁实现
*/
private String id;
private String type;
private double price;

public Motovercal(String id, String type, double price) {
this.id = id;
this.type = type;
this.price = price;
}

public abstract void show();//定义抽象方法