java SE 面向对象编程笔记1

.LOG

     java SE 面向对象编程笔记1

/*
1. 类和对象，类是抽象的的模板(person)，对象是具体的（具体的人），是类的具体表示方式。
2. 类所包含的内容是：数据和对数据的操作方式
     数据：成员变量（属性）。      对数据的操作：方法
3. 三大基本特征  继承（inheritance） 、封装（encapsulation） 多态（polymorphism）
   1。封装：将数据和方法放在类中。
   2.如何定义类：
     修饰符   class  类的名字     //class是关键字
{       
    //类的内容
}
3 方法的定义
      修饰符  返回类型   方法名称（参数）
 {
    //方法体
 }
4. Main()  方法是整个程序的入口 ，如果类的定义中没有main方法    则程序无法执行

eg:

*/

public class Test
{
//minus   multiply   divide   减，乘  除
public int add (int a ,int b )
{
return a+b;
}
public static void main (String[] args)  
{
Test test1 = new Test();

int x = 3;
int y = 8;

int a = test1.add(x,y);

}
}
/*
5. 方法定义不能嵌套，方法只能定义在类中。
6. 方法的执行，首先定义后使用（调用），当方法调用完毕后方法可以返回值，方法是否返回值是由方法的定义决定的
4， 如何生成对象，通过类生成对象，通常使用 new 关键字生成对象。
          public class Person {
 
 }
 类名 变量名 = new 类名();
 Person person1 = new Person() ;   // 对象是new 出来的那部分，然后赋值给引用变量
5. 目前方法调用是用个对象完成的， 
对象变量.方法名称（参数）;
6. 方法的注意事项
 1. 方法的返回类型和return后面的变量或者常量的类型一样
 2，方法调用时传递的参数和定义的参数保持一值，(个数、顺序和类型)
 3. 方法定义时的返回类型和接收时的变量的类型一致
7，方法定义时的参数叫形式参数，方法调用时的所赋予的具体值是实际参数
8，关键字   void 表示不返回值    不用return或者用 ’return;‘      //return表示返回给调用者




1. 类中的属性(property / attribute)又叫成员变量（member variable）， 
2, 对象（object）又叫实例（instance）。
3， 命名约定：
      1，类的首字母大写，每个单词的首字母大写
 2，方法 首字母小写，每个单词的首字母大写
 3，属性与方法完全一样的
4  属性，在类中的变量叫成员变量    在方法中的变量叫局部变量
5， 定义属性：   修饰符  类型 属性名称；
    使用属性，与使用方法一样。
6，局部变量使用前必须要申明并赋初始值，成员变量必须要声明但是可以不用赋初值（最好赋初值）；
7，成员变量和局部变量的区别和联系
     1. 使用前都需要声明
2. 局部变量必须要赋初值，成员变量使用前可以不初始化，如果不初始化则默认为：
整形类型的初始值为0，浮点型初始值0.0，char类型初始值为“\u0000”, boolean为false
8，引用类型 （reference type） 是用在对象上的，一个对象可以被多个引用指向，
     但同一时刻，每个引用只能指向一个对象。如果一个对象被多个引用指向，
     那么无论哪个引用对对象的属性进行了修改，都能反应到其他的引用当中。
eg:*/
     public class People
{
int age = 20;

public void change(People people)
{
people = new People();      //people引用指向了另一个新对象
people.age = 30;            //新对象的age为30
}

public void change2(int age )
{
age = 40;
}
public static void main (String[] args)
{
People people = new People();      //new 出来的才是对象，第二个people是引用变量，
                                  //      也就是说people引用指向了对象。
int age = people.age ;
System.out.println(age);
people.change(people);     // change(people)中的people是另外的一个引用，这个引用也指向了people对象。
// 该引用退出change后就不存在了
int age2 = people.age;       //people为main中的对象
System.out.println(age);

int i = 10;
people.change2(i);
System.out.println(i);    //结果是i=10  不是40，以为原生数据类型值互不影响。     
}
}


/*
9. 类中的属性是对象自己的，方法是共享的（内存中有方法区）。
10. 参数（param）传递的规则：
       1  如果传递的是原生数据类型，则传递后实参和形参的值不会相互影响，
          而引用的值会相互影响（引用传递的是对象或者说是地址）。总之，都传递的是值。例如上面的程序。
11. 构造方法(Constructor)：用于完成对象属性的初始化工作。
      特点：1，名字与类名完全一致（包含大小写），
       2，没有返回类型，连void都不能出现。
       3，如果定义类时，没有为类声明构造方法，java编译器会自动的为类添加一个默认构造方法
         （没有参数且方法体为空）  
4，如果声明了构造方法则java编译器就不会添加默认构造方法
   5，不能显式调用类的构造方法时，构造方法通常是通过 new 关键字隐式调用。
12，new 关键字在生成对象时完成了三件事：
1，为对象开辟内存空间，
2，调用构造方法，
        3，将对象的地址返回给引用。
13, new 对象时，对象类型后面的（）里面的是构造方法的参数。  小括号中的实际参数应该和
构造方法中的形参保持一致（类型，数量，顺序）。
14. 方法重载（overload）：表示两个或者多个方法的名字相同，但是方法参数不同。
参数不同：
1. 参数个数不同
2. 参数类型不同
3. 参数顺序不同
注意：方法的返回值对重载没有任何影响。
15，构造方法的重载：   
1，只需看参数即可。
2，构造方法之间的调用，在一个构造方法中调用另一个构造方法，只需在当前的
   构造方法中第一行用this();，this（）中的参数是第二个构造方法的参数。
*/
public class ConstructorOverload
{
public ConstructorOverload()
{
this(3);       //调用另一个构造方法，必须在本方法体的首行

System.out.println("test");
}


public ConstructorOverload(int i)
{
System.out.println(++i);
}


public static void main(String[] args)
{
ConstructorOverload col = new ConstructorOverload();


}
}
/*
16, 方法覆盖（override）： 子类和父类的方法返回类型，方法名称，参数一样 。      //eg：inheritanceest2
方法重载和覆盖：
1，重载是一个类内部的多个方法之间的区别
2，覆盖是子类重写父类的方法
注意：在普通方法中super可以放在任意位置（因为父类对象已经存在）。
*/
public class InheritenceTest2
{
public static void main(String[] args)
{
Dog dog = new Dog();
dog.run();
}
}


class Animal
{
public void run()
{
System.out.println("animal is running");
}
}


class Dog extends Animal
{
public void run()
{
System.out.println("dog is running");
super.run();    //调用父类的run方法，可以不放在方法体的首行
//因为父类对象已经生成
}
}
/*
17，java.long.Object类是java中所有类的直接或者间接父类。（根类）
18，继承（inheritance）：java是单继承的，表示一个类只能继承一个类，被继承的类是父类或者基类（base class）继承的类是子类。
       1，继承用extends
  2, 当生成子类对象时，java默认首先调用父类的不带参数的构造方法，     //super是显示调用父类方法    this表示当前对象的         
     然后执行该构造方法，生成父类的对象，然后再调用子类的构造方法生成子类的对象。
 （想生成子类对象必须先生成父类对象）
  3，super 表示对父类对象的引用。(与this一样，必须是构造方法的第一句)
  4，如果子类使用super（）显示的调用父类的构造方法则java不再再去找父类的默认构造方法。
  5，关于继承的3点：
        1，父类有的子类也有，
2，父类没有的子类可以增加
3，父类有的子类可以改变
  6，注意事项：
1，构造方法不能继承
2，方法和属性能继承
3，子类的构造方法隐式的调用父类的不带参数的构造方法
4 ，当父类没有不带参数的构造方法时，子类需要使用super来显示的调用父类的构造方法，
   super指的是对父类的引用（super必须是构造 方法的第一句）。
*/
public class Child extends Parent
{
public Child()
{
super(1);
System.out.println("child");
}


public static void main(String[] args)
{
Child child = new Child();
}
}


class Parent
{
public Parent(int i)
{
System.out.println("parent");
}


/*
public Parent()
{
System.out.println("no args parent");
}
*/
}
/* 
19，多态（polymorphism）:父类的引用调用（指向）子类的对象（子类是父类，但是父类不是子类）。
1，  parenr p = new child();  当使用多态方式调用方法时，首先检查父类中是否有sing（）方法，
如果没有则编译出错；如果有再去调用子类的sing（）方法。      */
//eg： PolyTest

public class PolyTest
{
public static void main(String[] args)
{
//Parent parent = new Parent();
//parent.sing();

//Child child = new Child();
//child.sing();


Parent p = new Child();
p.sing();
}
}


class Parent
{
public void sing()
{
System.out.println("parent is singing");
}
}


class Child extends Parent
{
public void sing()
{
System.out.println("child is singing");
}
}


/* 2， 有两种强制类型转换：
1，向上类型转换：将子类型转换为父类类型。
2，向下类型转换：将父类转换为指向子类对象的类型（要使用强制类型转换）。
        eg： polytest4      */
public class PolyTest3
{
public static void main(String[] args)
{
//Fruit f = new Pear();
//f.run();
//Pear p = (Pear)f;
//p.run();
//Fruit f = new Pear();
//f.grow();
Fruit f = new Pear();
Pear p = (Pear)f;
p.grow();
}
}


class Fruit
{
public void run()
{
System.out.println("fruit is running");
}
}


class Pear extends Fruit
{
public void run()
{
System.out.println("pear is running");
}


public void grow()
{
System.out.println("pear is growing");
}
}
/*  
3,前期绑定：编译时知道类型。
4，后期绑定：运行时知道类型（多态为后期绑定,运行期的行为，动态的）
//eg： polytest5
实际项目中的多态    
*/
public class PolyTest5
{
/*
public void run(BMW bmw)
{
bmw.run();
}


public void run(QQ qq)
{
qq.run();
}
*/


public void run(Car car)
{
car.run();
}

public static void main(String[] args)
{
/*
PolyTest5 test = new PolyTest5();
BMW bmw = new BMW();
test.run(bmw);
QQ qq = new QQ();
test.run(qq);
*/
PolyTest5 test = new PolyTest5();
Car car = new BMW();
test.run(car);
QQ qq = new QQ();
test.run(qq);
}
}


class Car
{
public void run()
{
System.out.println("car is running");
}
}


class BMW extends Car
{
public void run()
{
System.out.println("BMW is running");
}
}


class QQ extends Car
{
public void run()
{
System.out.println("QQ is running");
}
}
/*
19.抽象类（abstract class ）：使用了abstract关键字修饰的类。  特点：不能生成实例 。 
20，抽象方法：使用abstract修饰的方法。  特点：有声明无实现（需要在子类中实现）。
抽象方法需要定义在抽象类中。
21  如果一个类包含了抽象方法，那么它一点是抽象类。抽象类可以包含普通方法。
如果一个类包含了抽象方法则一定要声明为抽象类。
抽象类不一定有抽象方法。
抽象类中可以有实现了的方法
如果一个类继承的父类是抽象类则子类必须实现父类的抽象方法。否责该子类必须声明为抽象类。*/
 // eg： Test2；
 
public class Test2
{
public static void main(String[] args)
{
Shape shape = new Triangle(10,6);
int area = shape.computeArea();
System.out.println("triangle:" + area);
shape = new Rectangle(10, 10);
area = shape.computeArea();
System.out.println("rectangle:" + area);
}
}


abstract class Shape
{
public abstract int computeArea();//计算形状面积
}


class Triangle extends Shape
{
int width;
int height;


public Triangle(int width, int height)
{
this.width = width;
this.height = height;
}


public int computeArea()
{
return (width * height) / 2;
}
}


class Rectangle extends Shape
{
int width;
int height;


public Rectangle(int width, int height)
{
this.width = width;
this.height = height;
}


public int computeArea()
{ 　
return this.width * this.height;
}
}


/*
20, 接口（interface）：接口的地位等同于class。接口中的所有方法都是抽象方法（abstract可以省略）。
1 接口可以看做是特殊的抽象类。
2 类可以实现（implements）接口。
3 如果一个类实现了一个接口则必须实现接口中的所有方法，除非该类是抽象类可以不实现方法。
4 多态就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的实例。
    关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式一样。
21， static （静态）关键字：可以用来修饰属性和方法还可以用来修饰类（后面讲）。
1， 修饰属性：静态变量（公共的，每个对象所共有的。每个对象都可以修改该值）
 可以用类名访问静态变量，（java中推荐使用类名访问成员变量）。
2， 修饰方法：静态方法（使用和静态变量使用方式一样）
3， 静态方法只能被继承，不能覆盖非静态方法，也不能被非静态方法覆盖，只能覆盖（实质是hide）静态方法（继承后如果有两个相同的类方法，
调用哪一个则取决于对象是哪种类型，是什么类型则调用该类型对应的类方法，这时被
调用的类方法就隐藏了另一个类方法。）。总之，有　static　则不能覆盖，不管是谁覆盖谁。
eg ：staticTest3 
*/
public class StaticTest3
{
public static void main(String[] args)
{
M m = new N();
m.output();
}
}


class M
{
public static void output()
{
System.out.println("M");
}
}


class N extends M
{
public static void output()
{
System.out.println("N");
}
}
/*
4， static 代码块：静态代码块（static block）            
1， 静态代码块的作用是完成一些初始化工作。
2， 静态代码块是在类加载时就执行的，构造方法是在生成对象时执行的。
调用某个类生成对象时，首先是将类加载到JVM上，然后生成对象。
3， 静态代码块只执行（加载）一次且从最高类往下加载。
4， 在静态方法中不能访问非静态变量（静态只能访问静态，非静态可以访问所有）。
5， 不能在静态方法中使用 this 。     
//判断静态方法的使用权限时就用类名访问方法或属性，判断是否会改变对象的属性和方法。
22, final 关键字：final 可以修饰属性，方法，类。
１, 修养类：表示终态类，不能被继承。
２，修饰方法：终态方法，不能被重写（覆盖）。
３，修饰属性：常量。如果是原生类型的变量则不能改变，如果是引用类型的变量，则该引用变量
　 　指向的对象（地址）不能变，但是该对象的内容可以改变。
eg：FinalTest3
*/
public class FinalTest3
{
public static void main(String[] args)
{
· People people = new People();
//people.age = 20;
//people.address = new Address();
people.address.name = "shanghai";
}
}


class People
{
//final int age = 10;
final Address address = new Address();
}


class Address
{
String name = "beijing";
}

/* 4, final 的注意事项：           
1， 对于final类型的成员变量，一般来说有两种赋初值的方式：
a)  在声明final类型的成员变量时就赋上初值；
b)  在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋初值。     eg：finaltest4
*/
public class FinalTest4
{
final int a;


public FinalTest4()
{
a = 0;
}


public FinalTest4(int a)
{
this.a = a;
}
}