构造方法: 1.使用new+构造方法创建一个新的对象 2.构造方法是定义在Java类中的一个用来初始化对象的方法,构造方法与类同名且没有返回值 构造方法的语法格式: public 构造方法名(){ //初始化代码 } public后面没有返回值类型,构造方法名与类名相同,括号内可以指定参数 3.无参构造方法的使用 main(): Telphone phone=new Telphone(); class TelPhone: public Telphone(){ System.out.println("Telphone构造方法执行了"); } 如果我们没有指定一个无参的构造方法,那系统会帮我们自动生成一个无参的构造方法,如果我们对系统生成的无参构造方法不满意,可以自定义一个无参的构造方法 也就是说当我们创建对象的时候,其实我们执行的是构造方法 4.有参构造方法的使用 main(): Telphone phone2=new Telphone(4.0f, 2.0f, 2.0f); class Telphone: public Telphone(float newScreen,float newCpu,float newMem){ screen=newScreen; cpu=newCpu; mem=newMem; } 有参构造方法的目的就是初始化对象中成员变量的值 通过无参或者有参的构造方法都可以创建对象,但是后者不但可以创建对象而且可以给对象中的实例变量赋初值 5.当没有指定构造方法时,系统会自动添加无参的构造方法 6.当有指定构造方法时,无论是有参无参的构造方法,都不会自动添加无参的构造方法 7.构造方法的重载:方法名相同,但参数不同的多个方法,调用时会自动根据不同的参数选择相应的方法 8.构造方法不但可以给对象的属性赋值,还可以保证给对象的属性赋一个合理的值

每个人只有一个亲爹

看了好久的视频，总感觉两天不看就会忘。第一季就是很简单的语法，到了第二季就是语法类型，类和对象，构造方法，多态。使用一个类里的方法就要创建那个类的对象，然后对象.方法名();，重构方法（方法名和类名相同），就用创建对象的时候就会运行，还有成员内部类，方法内部类，静态内部类，其实就是把一个类当作一个成员变量放在内里，方法内部类就是把类当作一个一个变量放在方法里，方法在类里。使用方法，创建外部类的对象，再用外部类的对象创建内部类的对象，在使用内部类，外部类 外部对象 = new 外部类(); 内部类 内部类对象 = new 外部对象.内部类();静态内部类可以直接用静态内部类 对象名 =new 静态内部类();过了就是继承，子类拥有父类所有属性及方法，如果子类对父类方法不满意可以修改，继承初始顺序，父类属性，父类方法，子类属性，子类方法。后面有几个不同的名词，final终结类和方法不能继承,super使用父类,tostring获取地址,equals对比地址。这章节就是多态了，多态可以子类和父类做向上和向下的转换，向上转换属于自动转换，向下转换需要用If(a instanceof b){B b = (B)a;}就是从a转向b,前面要B b = new B(); A a = b; 抽象类就是定义父类的属性和方法为抽象类，然后子类会自动生抽抽象的父类属性和方法，使用起来也极其简单。

接口=全局常量+公共的抽象方法； 接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。 2.接口用interface定义，语法： [修饰符] interface abstract 接口名 [extends 父接口1，父接口2……] {//中括号中为可选项 零个到多个常量定义…… 零个到多个抽象方法的定义 } 3.接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口。 4.接口中的属性是常量（public static final修饰），系统会自动加上 5.接口中的方法只能是抽象方法（public abstract修饰），系统会自动加上 6.使用接口：一个类可以实现一个或多和接口，实现接口使用implements关键字。java中一个类只能继承一个父类，可以通过实现多个接口作补充 7.继承父类实现接口的语法： [修饰符] class 类名 extends 父类 implements 接口1，接口2……{ 类体部分}//如果继承的是抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法 如果要继承父类，继承父类必须在实现接口之前 接口命名时首字母为I，以区分类名。可通过add继承父接口 8.实现时可以利用接口的引用指向实现了接口的对象，调用其方法，如 ： IPlay ip1=new Psp();ip1.playGame(); 9.接口的使用还经常与匿名内部类配合（匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称） 语法格式： Interface i=new Interface(){ public void method(){ System.out.print("匿名内部类实现接口的方式……");}} //即通过创建接口的对象，直接写出实现的方法，再调用此方法 还可以直接创建并调用方法，如： new IPlay(){ public void playGame(){ System.out.println("……");}}.playGame();

多态： 指的是对象的多种形态 主要分为 引用多态 、方法多态 继承是多态的实现基础，别忘了子父类要有继承关系. 多态特性： 一、引用多态 1.父类引用可以指向本类对象 Animal obj1 = new Animal(); 2.父类引用可以指向子类对象 Animal obj2 = new Dog(); 但是我们不能用子类的引用指向父类对象 Dog obj3 = new Animal();//错 二、方法多态 1.在父类Animal中定义一个eat()方法，输出一个语句(动物有吃的能力); 在子类Dog中重写eat()方法，输出一个语句（狗是吃肉的）; 那么我们在测试类main函数里面，如果obj1.eat() ，那么调用的是父类的方法. 若用obj2调用eat()方法，那么调用的是子类的方法. 2.还有一种情况，比如创建一个继承父类Animal的子类Cat ，但是Cat里并不重写继承的eat()方法. 然后，我们在测试类main函数里创建一个子类对象, Animal obj3 = new Cat(); 然后调用 obj3.eat(); 那么，结果调用的则是子类继承父类的方法. (输出结果：动物有吃的能力) 3.最后一种特殊情况，多态的特性是不能使用的. 若在子类添加一个独有的方法 public void watchDoor() ，含有一句输出语句(狗具有看门的能力); 那么我们在测试类的main函数当中(得先定义好对象Animal obj2 = new Dog() )，就不能用obj2.watchDoor()，即不能通过父类的引用调用子类的方法.

package com.imooc.practice;

import java.util.*;

//所有类型的车可以提取出车这个父类，包含车名、载人数、载货量、租金4个属性

public abstract class Car {

//使用封装概念，只能通过指定的方法读写属性

private int rent; //日租金；

private int personnum; //载人数；

private int cargo; //载货量；

private  String name; //车名；

//使用set、get方法读写属性

public int getRent() {

return rent;

}

public void setRent(int rent) { 

this.rent = rent; 

}

public int getPersonnum() { 

return personnum;

}

public void setPersonnum(int person) {

this.personnum = person;

}

public int getCargo() {

return cargo;

}

public void setCargo(int cargo) {

this.cargo = cargo;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

//创建乘用车子类

public class PassengerCar extends Car {

public PassengerCar(String name, int personnum, int cargo, int rent) {

this.setName(name);

this.setPersonnum(personnum);

this.setRent(rent);

this.setCargo(cargo);

}

//重写toString方法返回乘用车车辆信息

public String toString() {

return this.getName()+"\t\t"+this.getPersonnum()+"\t\t"+this.getCargo()+"\t\t"+this.getRent();

}

}

//创建货运车子类

public class Truck extends Car {

public Truck (String name, int personnum, int cargo, int rent) {

this.setName(name);

this.setPersonnum(personnum);

this.setCargo(cargo);

this.setRent(rent);

}

//重写toString方法返回货运车信息

public String toString() {

return this.getName()+"\t\t"+this.getPersonnum()+"\t\t"+this.getCargo()+"\t\t"+this.getRent();

}

}

//创建皮卡子类

public class Pickup extends Car {

public Pickup(String name, int personnum, int cargo, int rent) {

this.setName(name);

this.setPersonnum(personnum);

this.setCargo(cargo);

this.setRent(rent);

}

//重写toString方法返回皮卡车信息

public String toString() {

return this.getName()+"\t\t"+this.getPersonnum()+"\t\t"+this.getCargo()+"\t\t"+this.getRent();

}

}

public class DadaTestDrive {

public static void main(String[] args) {

// TODO Auto-generated method stub

//对各类车实例化并保存到数组

Car[] cars = {

new PassengerCar("奥迪A4",4,0,500), 

new PassengerCar("马自达6",4,0,400), 

new Pickup("皮卡雪6",4,2,450), 

new PassengerCar("金龙",20,0,800), 

new Truck("松花江",0,4,400), 

new Truck("依维柯",0,20,1000)

};

//进入提示显示步骤

System.out.println("欢迎使用达达租出系统！");

System.out.println("***租车请按1，不租车请按2***");

//读取用户键入的信息并判断

Scanner input = new Scanner(System.in);

int key = input.nextInt();

if(key !=1) {

System.out.println("期待您下次光临！");

input.close();

return;

}else if(key == 1) {

System.out.println("您可租的车型及价目表如下：");

System.out.println("序号"+"\t车名"+"\t\t载人数（人）"+"\t载货量（吨）"+"\t租金（元/天）");

//输出实例化的各类车

for(int i=0; i<cars.length; i++) {

System.out.println((i+1)+"\t"+cars[i]);

}

}

//输入想租的车的数量

System.out.println("请输入要租车的数量：");

int carcount = input.nextInt();

//更新车辆数组

Car[] newCars = new Car[carcount];

int totalRent = 0;

int totalPerson = 0;

int cargo = 0;

for(int i=0; i<carcount; i++) {

System.out.println("请输入第"+(i+1)+"辆车的序号");

int serialNum = input.nextInt();

newCars[i] = cars[serialNum-1];

}

System.out.println("请输入您想租车的天数：");

int days = input.nextInt();

//计算租金

for(int i=0; i<carcount; i++) {

totalRent += newCars[i].getRent()*days;

}

//输出账单

System.out.println("您本次的租车账单：");

System.out.print("\n");

//列出所选乘用车并计算总的载人数

System.out.println("已选载人车：");

for(int i=0; i<carcount; i++) {

if(newCars[i].getPersonnum() != 0) {

System.out.println(newCars[i].getName());

totalPerson += newCars[i].getPersonnum();

}

}

System.out.print("\n");

System.out.println("已选载货车：");

//列出所选货运车并计算总的载货量

for(int i=0; i<carcount;i++) {

if(newCars[i].getCargo() != 0) {

System.out.println(newCars[i].getName());

cargo += newCars[i].getCargo();

}

}

System.out.print("\n");

System.out.println("共可载客"+totalPerson+"人");

System.out.println("共可载货"+cargo+"吨");

System.out.println("请付租金"+totalRent+"元");

System.out.print("\n");

System.out.print("谢谢惠顾，欢迎下次光临");

input.close();

}

}

Object类是所有类的父类,如果一个类没有使用extends关键字明确标识继承另外一个类,那么这个类默认继承Object类,且Object类中的方法适合所有子类 1.toString()方法 在Object类里面定义toString()方法的时候返回的对象的哈希code码(对象地址字符串) 如果我们在代码里面直接输出一个对象,会输出这个对象在内存中的地址,我们把它称为哈希码,哈希码是通过哈希算法生成的一个字符串用来唯一区分对象的 可以通过重写toString()方法表示出对象的属性 (我们经常在输出对象的时候希望得到子类的属性值,那么我们就要重写从父类继承来的toString()方法,eclipse中右键菜单栏-源码source-生成generate toString(),他就会根据我们对象的属性帮我们生成一个toString()方法来输出属性值) getClass()可以得到一个类对象,当我们new的时候得到的是一个类的对象如果对象调用getClass()方法我们得到的是类对象,类对象描述的是类的代码信息(类的代码信息:这个类有哪些属性\它是什么类型\变量名是什么\它有哪些方法\方法名是什么\方法里面的代码是什么;而类的对象关注的是对象的属性值的信息或者说这个对象的数据信息)

成员变量：在类中定义，用来描述对象将要有什么（属性）。可被本类方法和其他跟当前类有关系的方法使用。 局部变量：在类的方法中定义，在方法中临时保存数据。（只能在当前的方法中使用） 区别： 1.作用域不同：局部变量的作用域仅限于定义它的方法，成员变量的作用域在整个类内部都是可见的。 2.初始值不同：java会给成员变量一个初始值，java不会给局部变脸赋予初始值。 3.在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量。 4.两类变量同名时，局部变量具有更高的优先级。

1.对象的概念：对特定一个存在事物 2.什么是面向对象：以自我为中心对待一个特定事物存在，需要自己描述出来的符合的条件 3.类：是对象的一个属性一个特征，是你描述的条件，条件符合的多个对象可以归纳为一个类，也可以说这个对象含有这个类。 4什么是对象的属性：对象有的各种特征，他具有什么就是对象的属性。 5什么是对象的方法：对象能干什么 6类与对象的关系/区别：类是抽象的概念是一个模板，是条件信息。对象是一个具体的东西，是一个客观存在。好比是类是能打电话，能发短信的功能条件。而对象就是一部手机。

final关键字： 表示“最终的”，即不可修改。 final可以修饰类、方法、属性和变量 1、修饰类：不允许被继承 2、修饰方法：不允许被重写 3、修饰属性：则该属性不会进行隐式初始化（不会自动初始化），需要手动初始化或者在构造方法中初始化 （但二者只能选一，即只能初始化一次后便不能更改） 4、修饰变量，只能在声明的时候赋一次值，成为常量。 （static final 会使其成为全局常量）

重写方法的规则： 1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。 2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。如果在子类中写了一个只有返回类型不同的函数，将不是重写，且会报错 3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private） 4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如： 父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。 而重载的规则： 1、必须具有不同的参数列表； 2、可以有不责骂的返回类型，只要参数列表不同就可以了； 3、可以有不同的访问修饰符； 4、可以抛出不同的异常； 重写与重载的区别在于： 重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。 用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般. 重写是除了函数体其他必须完全相同，如果参数不同则是重载，如果参数相同而返回类型不同则会报错

引用类型转换： 1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换。 如：Dog dog=new Dog();Animal animal=dog;//正确，自动类型提升，向上类型转换 2.向下类型转换（强制类型转换），是大类型到小类型的转换（存在风险，溢出） 如：Dog dog1=(Dog)animal;//向下类型转换 3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。如： Dog dog=new Dog(); Animal animal=dog; Cat cat=(Cat)animal;//编译时不会出错（按Cat类型进行编译），但运行时会报错，因为它开辟的是Dog类型的空间，而（无法将引用类型进行转换）无法将dog对象转换成Cat类型，并且此方法对程序的安全性有影响。此时应该利用instanceof和if语句结合使用，进行验证，以保证程序的安全性，如： if(animal instanceof Cat){//判断animal类中是否包含Cat类型的元素，若包含则进行转换，instanceof返回值为布尔类型 Cat cat=(Cat)animal;}else{ System.out.println("无法进行类型转换");}

静态变量的访问可以不创建对象， 直接用 类名.静态变量 也可以创建对象用 “对象名.静态变量” 访问静态变量。 还可以通过改变 对象名.静态变量 来改变静态变量的值。 问：可以通过 “类名.静态变量” 访问静态变量 如：HelloWorld.className；也可以通过 “对象名.静态变量” 访问静态变量。但是，什么也不加，直接className也可以呀？是因为有什么弊端吗？ 答：静态变量是可以直接引用的，不过是不安全的。在访问静态变量的时候首选是类名.静态变量的方式，这不仅是因为它强调了变量的static的结构，而且在某些情况下它还为编译器进行优化提供了更好的机会 你看完下一节内容就明白了，因为我们的main（）前也有一个static关键字，这表明mian（）是一个静态方法，而静态方法是可以直接访问静态变量的。 你所谓的直接className是在一个类里面才行的通，出了这个类就报错。 1.静态成员变量是属于整个类的全局变量，它不单属于某一个对象；普通成员变量是属于类中的对象，它不能被所有对象共享。 2.静态成员变量必须在全局进行定义，而由于普通成员变量在创建一个对象的时候可以对它进行初始化，因此就不需要单独对它进行定义，只要声明即可。 3.静态成员变量在没有对象之前就存在。 1·、static应用范围：可用于内部类、方法和变量。 2、标记一个方法为static，意味着这个方法，被所在类的所有实例公用，在类装载时被首先执行，执行一次即被所有该类的实例共享，同时意味着： A、static方法内部不能引用非static变量。 B、static方法不能被子类重写为非static方法。 C、父类的非static方法不能被子类重写为static方法。 D、static代码块可以用static {}来完成，在类被第一次装载时执行初始化，先于静态方法和其他方法的执行。 3、标记一个变量为static，则该变量在内存中有不变的位置，相当于全局变量，所有类的实例都访问同一个存储变量区域。对其修改对于所有类的实例来说都是可见和一致的。

抽象类定义 1、语法定义： 抽象类钱使用abstract关键字修饰，则该类为抽象类。 2、应用场景： a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法 b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。 3、作用： 限制规定子类必须实现某些方法，但不关注实现细节。 4、使用规则： a、abstract定义抽象类 b、abstract定义抽象方法，只有声明，不需要实现 c、包含抽象方法的类是抽象类 d、抽象类中可以包含普通的方法，也可以没

super关键字指的是父类 子类的构造的过程当中必须调用其父类的构造方法 相当于super();默认是调用无参的 如果子类的构造方法中没有显示调用父类的构造方法,系统会默认调用父类无参的构造方法. 如果要显示的调用父类的构造方法,必须在子类的构造方法第一行中添加super(); 如果子类构造方法中既没有显示调用父类的构造方法,而父类又没有无参的构造方法,则编译出错,如果父类是定义了有参的构造方法,那么子类必须super.(父类的参数),或者父类中添加一个无参的构造方法,否则出错 因为默认调用的是super();是无参的。 一个类中没有定义构造方法,则系统会默认为此类定义一个无参的构造方法.如果自定义了一个带参的构造方法,则系统不会为其添加无参的构造方法.