java笔记05 面向对象oop（含大量习题）

java OOP 面向对象的程序设计  
概念：
（1）类 ：抽象化对象的模板  研究对象中主要的特点拿出来 不要次要的 
（2）对象：类的具体实例   
（3）属性：描述对象的静态信息  变量的定义 
public class Human
{
    String name;
    int age;
    Stirng sex;
}
(4)行为  对象内部的各种动态信息   方法 

面向对象的特点 
1.封装：将事物的内部实现细节隐藏起来，对外提供一致的公共接口访问
2.继承：面向对象中类与类的一种关系  当一个类拥有另一个类 的数据和操作 就称这两个类有继承关系  被继承的类 被称为 父类（超类） 继承的类 被称作子类 java 中类与类之间 
没有多继承  单项继承  接口是多继承的  
3.多态：多种表现形式          不同对象调用同一种方法产生的结果不同   
（1）方法多态：方法的重写 方法的重载  
（2）类的多态：原生类 派生类    抽象类  接口            
4.抽象：研究对象中主要的特点拿出来 不要次要的 

类   java程序的编写实际上就是类的编写过程
（1）如何定义类
语法 ：  访问修饰符  class  类名
{
    类体；
}
public  创建一个公有的类 （java程序中有且仅有一个类被声明修饰为public 一旦
这个类被修饰为public 那么文件名就必须跟该类的名字相同）   缺省  
备注：在一个java文件 可以包含很多个类（class）一旦这个类被修饰为public 那么文件名就必须跟该类的名字相同） 一个java文件中可以没有类被修饰为public  一般我们习惯于把主方法所在类  作为文件名
两种变量的定义 
1.成员变量2局部变量 
成员变量是定义在类体中的变量 
局部变量  定义在方法体 中（方法的参数）
2.成员变量的隐藏（当局部变量和成员变量同名的时候成员变量会被隐藏）
成员变量 主要的作用是 在一个类中参数传递   局部变量 赋值 
this                      this.成员变量的名字=局部变量名;
3.方法 实现功能 
如何定义方法 语法
（1）访问权限  返回值类型  方法名(参数1，参数2，.....)  0   空参方法 和带参方法
{
    方法体；
}
public   缺省   
返回值类型  
double area()只能求半径为5的圆的面积
{
    double r=5;
    double pi=3.14
    double area=pi*r*r;
}
double area(double r) 所有的半径
{
    double pi=3.14
    double area=pi*r*r;
}
（2）返回值 可以是java中任意的一种数据类型 基本数据类型 引用数据类型14
    有一些方法不需要有返回值 
public  void 方法名(参数....)
带返回值的方法一般的会放在输出语句中
不带返回值的方法 一般会自带输出语句

protected    private
构造方法  构造器  对象
1.构造方法的方法名一定要和类名相同 class A    void  A()
2.构造方法没有返回值 （void不写）      A()
3.构造方法的主要作用完成类的实例化操作   创建对象
4.构造方法只能通过new运算符来调用
5.一个类中可以有很多个构造方法  但是 参数必须不相同
备注：如果在一个java类中我们没有创建构造方法 系统会为每一个创建的类 创建一个空参的构造方法 但是如果我们创建了带参的构造方法 原来的空参构造方法就会被覆盖 如果我们还想使用空参的构造方法 只能重新的再次声明
对象
1.如何创建对象
语法：
类名 对象名=new 构造方法；
class Student
Student stu=new Student()； 声明对象  stu  为 该对象分配内存空间
对象被创建  一定new  NullPointerException  空指针异常
2.对象的使用  
对象操作成员变量   对象名.成员变量  =值  
对象调用方法   对象名.方法名()
友情提示：每一个java文件中最好创建两个以上的类  public class 里面主方法
主方法  只放对象的声明 和方法的调用以及输出 其他的类中会具体的写明

static 静态
修饰方法  类方法

修饰变量（成员变量）  类变量

类调类  通过类名 来调用 类变量 和类方法
实例调实例   对象
可以不用创建对象 来实现 方法的调用以及变量的赋值
备注 ：尽量不要让实例化的对象操作用static 修饰的变量或方法
static关键字的用法
1.如果方法是的所有参数可以直接给定 不需要访问实例变量 该方法可以被定义为类方法
2.如果方法仅仅访问类变量 可以将其定义为类方法
静态代码块
static{
    语句；
}
使用static修饰的语句会被优先执行   在一个java文件中可以有很多个静态代码块
每一个静态代码块 都优先于 该文件中的其他方法之前执行   静态代码块执行的顺序跟他的位置有关  
this     this.成员变量
this是java中的一个关键字  表示某个对象（当前类的对象）
java中的包  文件夹 
创建包的语句 （加载每一个java文件的第一行）
package  test.test1 

 Example1    c:\test      test1  
import  包名  引入包 
常见的java的工具包
1.java.lang java语言的核心类库 基础类 基本数据类型 数学类  字符串  默认被加载
2.java.util  java中的一个很有用的工具包  Scanner 日期类 时间  堆栈 
3.java.io 输入输出   提供了对文件的操作  
4.java.net 实现网络功能  
5.java.sql 数据库的一些工具

this
static  类变量   类方法  类 
static{语句}

package  包名  
jar java压缩文件   
api文档  
1.访问权限  
类     public   缺省  
变量
方法
private 封装 

public 公有的 protected 受保护   缺省  private 私有的 
public void test()
{

}
一元二次方程  
Math.sqrt() 开平方
1.面向对象的特点   （1）继承（2）封装（3）多态（4）抽象
2.类  对象
3.变量 实例变量  类变量
4.构造方法的特点   用法
5.this
6.static
7.访问权限  
面向对象高级部分
1.继承
继承是一种创建新类的机制 类的继承也被称作类的派生  
2.语法

class 子类 extends 父类
class B extends A
{
    
}
java继承
A   B    C
A extends B   B extends C
B是A的直接父类  C是A的间接父类  不允许多继承 一个或多个子类只能有一个直接父类 

继承中 如果父类中没有空参的构造方法  子类中必须创建 非空参构造方法
备注：当子类构建构造方法的时候总是调用父类的构造方法
如果父类中含有空参构造方法  子类中就可以任意的创建构造方法
1.继承的限制
（1）子类和父类如果在同一个包中  
子类能继承 非private 的成员变量和方法
（2）子类和父类不在同一个包中
子类只能继承 public  protected 的成员变量和方法
2.继承的原则
（1）java语言中只允许单一的继承 一个或多个类 只能有一个父类   
（2）继承具有传递性 
（3）继承不能循环
（4）Object作为java最顶层的父类（除了Object类之外 其他类都有父类 ）
3.子类对象的构造
多态  
 重载  方法名相同 参数不同（个数不同  数据类型不同 跟方法的返回值 以及访问权限没有关系 方法重载一般出现在一个类的内部 主要的作用是扩大方法的功能）
方法的重写 
 方法名相同 参数也相同（方法的重写主要出现在继承中 子类重写父类的方法 扩大父类方法的执行功能）
 

1.重载    重写
在子类创建构造方法的时候总是调用父类的某一个构造方法 （空参会调用父类中的空参构造方法 如果父类中没有空参的构造方法 报错 
方法重写  
子类继承父类 
直接重写父类中的某一个方法   方法名必须相同 参数必须相同
方法重写的注意事项
（1）子类继承父类重写父类的方法 不能降低父类方法的访问权限
（2）子类不能抛出比父类方法更多的异常 
（3）方法重写只能存在于 有继承关系的两个类中
(4)父类的私有方法不能被子类重写
2.super        this 
super()表示当前类的父类空参构造方法   this()表名当前类的空参构造方法
无论是super（） 还是this（）如果出现在构造方法中 必须放在构造方法方法体的第一行
在构造方法中不能同时使用this() super()
3.final关键字    类  变量  方法
final class A
final  int a
final void test()
{
    
}
final 修饰类  被称作最终类   没有子类        String 
final 修饰变量  常量   连接数据库的URL   final String url="http://127.0.0......"
final 修饰方法  不能被子类重写  
对象的造型  
A extends  B
A a=new A();
B b=new B();

A a=new B();   将B类对象的引用赋值给 A类对象 将父类对象的引用赋给子类对象
对象的下造型   需要添加强制类型转换
B b=new A();  将A类对象的引用赋给B类对象 将子类对象的引用赋给父类对象
 new 为对象 开辟内存空间    内存地址（引用）
对象的上造型  
public static void main(String[] args) 
    {
        A a=new B();//子类对象赋给父类对象 上造型
        B b=(B) new A();//父类对象赋给子类对象  下造型
    }
对象的造型机制的原则
1.造型机制 必须存在于继承关系的类中 不能转换没有继承关系的实例
2.一个类的实例也是其基类的实例

父类对象通过 下造型可以访问子类中的方法 但是只能访问子类重写的父类方法

1.接口多态  
接口回调 ：把实现某一接口的类创建的对象的引用赋给该接口变量 那么该接口变量
就可以调用被类实现的接口方法
interface A
{
    b();
}
class C implements A
{
    b()
    {
        System.out.println("OK");
    }
    A a=new C();
    a.b();

}

内部类 ：在一个类的类体中定义其他的类   内部类所在的类被称为  外包类  
1.语法格式
类的访问修饰符 class  类名 extends  父类 implements 接口列表
{
    类体
    public class 类名
    {
        
    } 
}
实名内部类 访问修饰符 增加了  protected  private 
2.使用方式
外包类名.内部类名 对象名=new 外包类名(参数列表).new 内部类名(参数列表);

这部分是java最重要的部分之一，java中我个人认为最重要的只有两部分就是面向对象oop和集合，后面会经常使用的到，而向io流啊，线程啊这些虽然也是面试高频，但是学到后面几乎就是用不到。这部分知识点也是繁多，我这里可能记的也比较乱，但是大家只需要记住oop面向对象三大特性 封装 继承 多态就好。这里的习题也是所有章节中最多的，多多练习。

练习：

例1：

例2：

例3：

 

例4：

例5：

例6：

例7：

例8：

 

这里有个让我困惑了很久的一个问题，子类不是能继承父类的属性么，为什么这个值带不过去。

然后我们给父类的属性加上static:

 

这样子类就能得到父类的属性值。

例9：

例10：

例11：

 例12：

例13：

例14：

例15：

例16：

这个题比较神奇，它就是一个类，但是也可以使用实例化的方法在主方法中调用主方法外的方法。

例17：

 上面的习题累*再累加也可以这么做。可以写成两个类。

例18：

 

上面的题也可以这么写：

例19：

例20：

例21：

例22：

 

例23：

例24：

例25：

例26：

 

例27：

这个题主要是使用了接口回调。

例28：

例29：

例30：

我们可以在两个java文件里进行类的实例化调用。

例31：

例32：

 

 

 

我们这个题是做一个对数组根据某个属性值升序排列数组内容，我们这里是一个给数组，这个类实现了Comparable接口。我们只需要自动调用hashCode方法，equals方法，compareTo方法。

就可以进行排序了。并且这里给出了3种做法，可以直接用Arrays.sort二分排序。也可以使用匿名内部类的方式。这里使用的是lambda表达式的方式。这种方式不是很常见，可以作为了解。 

这部分是java基础中最为重要的章节，所以练习题也最多。这些题如果做得轻车熟路，一打眼就明白题的逻辑的话。基本上也就贯通了面向对象oop的知识了。 这部分一定是要多去做题才能真正的体会和理解。