黑马程序员_基础、封装、继承、多态

 

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

 

 

面向对象的特征：封装，多态，继承 

封装  

    封装、构造函数、this关键字。封装：是指隐藏对象的属性并实现细节，仅对外提供公共访问的方式，也就是将一类事物的特征和行为定义在类中,使用这个类创建对象, 那么这个对象就有了自己的属性和方法。**封装的属性：定义类的时候，成员变量都要用private修饰，私有化不允许其他类进行访问，提高安全性；如果想要类外修改，可以定义set方法，在方法中进行修改；如果需要类外获取，可以提供get方法，在方法中进行获取。设置（set）成员变量的方法：**返回值类型为void；**方法名为set开头后面跟属性名，属性名的首字母大写，例如：name属性就是setName，age属性就是setAge;**参数列表需要一个参数，类型和成员变量的类型一致；例： public static voidsetName(String name){};获取（get）成员变量的方法：**返回值类型和成员变量类型一致；**方法名为get开头后面跟属性名，属性名的首字母大写，例如：name属性就是getName，age就是getAge；**没有任何参数；例： public staticString getName(){};***封装原则：**将不需要对外提供的内容都隐藏起来；**把属性都隐藏，提供公共方法对其访问；***封装优点：**将变化隔离；**便于使用；**提高重用性，安全性；class Test6 { publicstatic void main(String[] args) { //创建一个person对象； Person p = new Person(); p.setName("lisi"); p.setAge(22); p.eat(); }}//创建一个类class Person { //将不需要对外提供的内容都封装，私有化； privateString name; //提供对外访问的方法，set和get publicvoid setName(String n) { name = n; } publicString getName() { return name; } //私有化年龄； privateint age; publicvoid setAge(int a) { age =a; } publicint getAge() { return age; } voideat() { System.out.println(name +" ," +age+"吃饭"); }}二，private和public的区别public是共有的，所有的类都可以使用，目前在无包的情况下和无修饰符一样，其他类可以访问private私有的，是权限修饰符，用于修饰类中的成员（成员函数和成员变量），只能在当前类访问，其他类都不能使用；**被private修饰的成员变量通常会对应2种访问方式，get和set，之所以对外提供访问方式，就因为可以再访问方式中加入逻辑判断等语句，对访问的数 据进行操作，提高代码的健壮性；***注意：封装不是私有，私有仅仅是封装的一种表现形式；三，构造函数（1）构造函数：构造函数是一种特殊的函数；函数名和类名相同，没有返回值类型，不可以写return，创建对象时自动调用；在定义一个类的时候，如果希望别人创建对象时就执行某些操作，那么就可以在构 造函数中定义一些代码；例如：class Person { //创建无参的构造函数Person() { System.out.println(“person run”); }}class PersonDemo { public static voidmain(String[] args) {//创建person类的对象； Person p = new Person();}}new Person（） 对象一建立，就会调用与之相对应的构造函数Person（）；用于给对象初始化；（2)构造函数的重载：构造函数和普通函数一样，是可以重载的，函数名相同，参数列表不同，就是重载，在调用的时候，根据实际参数的类型，调 用对应的构造函数(3)什么时候使用构造函数？如果创建一个对象的时候，需要给这个对象的成员变量进行赋值，那么就可以使用 有参的构造函数，传入一些数据，构造函数中对成员变量赋值；(4)自动生成构造函数;定义一个类的时候，如果没有任何构造函数，那么编译时会自动生成一个无参的构 造函数，其中没有任何代码；***注意：只要写了任意一种构造函数，都不会再生成无参的构造函数了创建对象时一定对调用构造函数，无论有参的还是无参的，如果找不到都会报错；以后在定义类的时候，除非要求别人传入一个有参的构造函数，否则最好写一个无参的构造函数；class ConstructorDemo { public static voidmain(String[] args) { Person p1 = new Person(); Person P2 = new Person("lisi"); Person p3 = new Person(22); }} class Person { //无参的构造函数 public Person() {}//有参的构造函数， publicPerson(String name) { System.out.println("name="+name); } Person(int age) { System.out.println("age="+age); }}(5)构造函数的访问权限通常构造函数的访问权限都是公有的，除非不想让别人创建对象；（6）构造函数和一般函数的区别;1， 写法上不同2， 在运行上也有不同，构造函数是在对象建立就运行，给对象初始化，一个对象建立，构造函数只运行一次;而一般函数是对象调用才执行,一般函数可以被对象调用多次；（7）构造代码块： 对象建立就运行，且优先于构造函数执行； 构造代码块和构造函数区别： 构造代码块中定义的是不同对象共性的初始化内容，是给所有对象统一初始化，只要有对象建立就执行，而构造函数是给对应的函数进行初始化，对象建立只运行一次；四，this关键字1，构造函数中调用其他构造函数在构造函数的第一条语句，可以使用“this（参数）”形式调用当前类的其他构造函数；***注意：在构造函数中的调用不要形成递归；2，在函数中当做一个引用在调用一个函数的时候，函数中可以使用this来代表调用当前函数的对象，哪个对象调用函数，this就代表哪个对象；在局部变量和成员变量重名的时候，如果只想访问成员变量，那么就可以使用“this.变量名”的方式来访问。//练习this关键字；调用构造函数，class ThisDemo { public static voidmain(String[] args) { Person p1 = new Person(); p1.eat(); Person p2 = new Person("Tom"); p2.eat(); Person p3 = new Person(23); p3.eat(); Person p4 = new Person("Jom",24); p4.eat(); }}class Person { private Stringname; //成员变量私有 private int age; //构造函数重载， public Person() { this("nono",0); //调用当前类含有两个形式参数的构造函数， } publicPerson(String name) { this(name,0); //调用当前类含有两个形式参数的构造函数， } public Person(intage) { this("no",age); //调用当前类含有两个形式参数的构造函数， }//含有两个参数的构造函数，被其他三个构造函数所调用； publicPerson(String name, int age) { this.name = name; this.age = age; } public void eat() { System.out.println("I'm "+ name+",my age is"+age+" eatfood"); }}

继承

1，向上转型

子类对象可以当做父类对象使用，因为父类有的功能子类都有；

父类对象不能当子类使用，因为子类有的功能父类不一定有；

父类变量引用子类对象时，不能调用子类特有方法，因为编译时会报错；

2，强制类型转换

子类当父类来使用时，如果想调用子类特有方法，需要强制类型转换为子类，才能       调用；

如果父类变量记住的是父类对象，这时不能强转；

强转的代码在编译时不会报错，通常会用instanceof判断之后再进行强转；

例如: class Person {}   定义一个人类

class Student extends Person {} 定义一个学生类继承人类

class Demo {

Person p = new Student();   是向上转型，子类当父类使用

If(p instanceof Student )              使用instanceof判断p是否属于学生类

return Student s = (Student ) p;            如果是，则强转

}

3，重写方法

子类可以重写父类方法，一旦重写，调用时就会找子类重写后的方法；

如果需要调用父类被覆盖的方法，可以使用super关键字；

重写方法时，返回值类型和参数列表必须全部相同，访问权限不能更低；

访问权限排列：

public > protected > default > private

4，@Override

注解，加载方法前，用来检查当前方法是否覆盖父类的一个方法

如果成功覆盖，编译会通过；如果没有覆盖，编译会报错；

class Demo {

       public static voidmain(String[] args) {

              //子类对象当父类对象使用

              Person p = new Student();

              //父类变量使用子类特有方法，会报错

              //p.study();

              //使用instanceof判读变量类型，如果是，父类变量强制转换成子类变量；

              if( p instanceof Person) {

                     Student s =(Student)p;

                     s.study();

              }

              else

                     System.out.println("不是Person类型，不能转换");

       }

}

class Person {

       String name;

       int age;

       

       public void eat() {

              System.out.println("吃饭");  

       }

 

}

class Student extends Person {

       //检测子类的eat方法是否覆盖了父类的eat方法

       @Override

       //父类中的eat方法重写

       public void eat() {

              System.out.println("Student吃饭");     

       }

       public void study() {

              System.out.println("学习");  

       }     

}

多态

1，多态

一段代码可以运行出多种形态，子类当父类来用，父类变量引用哪种子类对象就调用哪个类的方法；

2，使用多态

在定义函数的形参时，可以定义成父类类型，调用时可以传入所有子类对象；

//练习多态，

class Demo {

       public static voidmain(String[] args) {

              //创建苹果对象，并调用其方法；

              //Apple a = new Apple();

              //a.squeeze();  

              

              Juicer j= new Juicer() ;

              j.run(new Apple());

              j.run(new Orange());

       }

}

//定义榨汁机类，简化代码；

class Juicer {

       public void run(Fruitfruit) {

              fruit.squeeze();       

       }

       //public void run(Orangeorange) {

       //     orange.squeeze();   

       //}   

}

//发现苹果和橘子类中的方法相同，只是打印主体不同，所以把这段代码提取出来，定义一个父类，

//让苹果和橘子类继承父类，这样可以简化juicer类的代码，提高代码的复用性；

abstract class Fruit {

       public abstract voidsqueeze() ;     

}

class Apple extends Fruit {

       public void squeeze() {

              System.out.println("榨了一杯苹果汁");

       }

}

class Orange extends Fruit {

       public void squeeze() {

              System.out.println("榨了一杯橘子汁");      

       }     

}

3，多态的体现

       父类的引用指向了自己的子类对象。

       父类的引用也可以接收自己的子类对象。

4，多态的前提

       必须是类与类之间有关系。要么继承，要么实现。

       通常还有一个前提：存在覆盖。

5，多态的好处

       多态的出现大大的提高程序的扩展性。

6，多态的弊端：

       虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败；

在运行时期：参阅对象所属的类中是否有调用的方法;

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边;

在多态中，成员变量的特点：

无论编译和运行，都参考引用型变量所属的类；

在多态中，静态成员函数的特点：

无论编译和运行，都参考引用型变量所属的类；

基础

java标识符
    标识符是以字母，下划线，美元符开始的一个字符序列，后面可以跟字母、下划线、美元符 、数字
 java关键字
    具有专门的意义和用途，不能当作一般的标识符使用，这些标识符成为保留字，也称为关键字
 java注释和分隔符
    java的注释有三种形式
    行注释//注释内容
    块注释/*注释内容*/
    文档注释/**
注释内容
    java中圆点“.”、分号“;”、空格 、花括号{}、等符号具有特殊的分隔符作用
   
java的数据类型
    数据类型的分类
    基本类型：也叫简单数据类型，他代表的是语言能处理的基本数据。
    引用类型：也叫复合数据类型，其数据存储取决于数据类型定义
常量与变量
    常量：可分为两种，一种是直接常量，其字面代表了常量的值，
    另一种用标识符表示，和变量定义的方式差不多，只需要用final修饰
    表示数据在执行过程中不能修改。
    变量：变量要先定义后使用，定义形式type name=value[,name[=value]...]
基本数据类型

整型数据
    整型常量就是不带小数点的数，但包括负数在java中分为long，int，short，byte
    十进制：数据以非0开头
    八进制：数据以0开头
    十六进制：数据以
    默认是int类型的
        浮点型数据：
            就是带小数点的数，分为flaot类型和duoble类型字

        符型数据：
            就是字符数据，char类型
        布尔型数据：
            boolean类型有两种数值，false和true
数据类型之间的互相转换
    隐式转换：
        当运算的两个数据不同时，占内存少的会向占内存大的类型转换
    强制转换：
        当运算的两个数据不是同一种类型时，可以把其中一个强制转换成相同的类型格式，(基本类型)数据
运算符和表达式
算术运算符
  
    其中包括加号（+）、减号（-）、除号（/）、乘号（*）以及模数（%，从整数除   法中获得余数）。
关系运算符
    关系运算符生成的是一个“布尔”（Boolean）结果。它们评价的是运算对象值之间的关系。若关系是真实的，关系表达式会生成true（真）；若关系不真实，则生成false（假）。关系运算符包括小于（ ）、小于或等于（ =）、等于（==）以及不等于（!=）。

逻辑运算符
    与（&）、非（~）、或（|）、异或（^）
位运算符
     &   按位与 
     |   按位或 
     ^   按位异或 
     ~   取反 
     <<   左移 
     >>   右移 

 赋值运算符
      =
     +=
     -=
     *=
     ++
     --等