面向对象基础知识

面向对象是相对面向过程而言的 面向对象和面向过程都是一种思想 面向过程强调的是功能行为 面向对象将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的

面向对象的特征：

  • 封装
  • 继承
  • 多态

java中用类Class来描述事物： 属性：对应类中的成员变量 行为：对应类中的成员函数

成员变量 成员变量定义在类中，在整个类中都可以被访问 成员变量随着对象的建立而建立，存在于对象所在的堆内存中 成员变量有默认初始化值

局部变量 局部变量之定义在局部范围内，如函数内 局部变量存在栈内存中 作用的范围结束，变量空间会自动释放 局部变量没有默认初始化值

匿名对象 匿名对象是对象的简化形式 匿名对象有两种使用情况： 当对象方法仅进行一次调用时 匿名对象可以作为实际参数进行传递

heap-stack

java -x 输出java的非标准选项 java -Xss<size> xxx 设置stack大小 如：java -Xss521k

java -Xmx 设置堆最大值 java -Xms 设置堆初始值

java中对象和数组都位于堆内存中，局部变量函数参数等都位于栈内存中

封装

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

封装原则： 将不需要对外提供的内容都隐藏起来 把属性都隐藏起来，提供公共方法对其访问

代码例子：

  1. package study_java.ex01;
  2.  
  3. public class ClassDemo1 {
  4.     public static void main(String[] args){
  5.         Man man = new Man();
  6.         // 不能直接通过man访问到money，只能通过getMoney方法
  7.         System.out.println(man.getMoney());
  8.         man.addMoney(100);
  9.         System.out.println(man.getMoney());
  10.         // 对于public的变量我们可以直接通过man访问
  11.         System.out.println(man.age);
  12.     }
  13.  
  14. }
  15.  
  16. class Man{
  17.     private int money = 100;
  18.     public int age = 23;
  19.  
  20.     // 通过封装的方式获取money
  21.     public int getMoney(){
  22.         return money;
  23.     }
  24.     // 通过封装的方式修改money
  25.     public void addMoney(int num){
  26.         money += num;
  27.     }
  28. }

private关键字

是一个权限修饰符 用于修饰成员变量和成员函数 被私有化的成员只在本类中有效

常用于： 将成员变量私有化，对外提供对应的set，get方法对其进行访问，提高对数据访问的安全性

构造函数

函数名与类名相同 不用定义返回值类型 没有具体的返回值

作用：给对象进行初始化

  1. package study_java.ex01;
  2.  
  3. public class ConstructDemo1 {
  4.  
  5.     public static void main(String[] args){
  6.         Dog d = new Dog("aa");
  7.         d.watch();
  8.     }
  9. }
  10.  
  11. class Dog{
  12.     private String name;
  13.     private String color;
  14.  
  15.     // 构造函数
  16.     public Dog(String n){
  17.         name = n;
  18.         System.out.println("new Dog()");
  19.     }
  20.  
  21.     public void watch(){
  22.         System.out.println("旺旺");
  23.         System.out.println(name);
  24.     }
  25.  
  26. }

构造代码块也是类成员，是为构造函数添加共有的一些内容 并且构造函数先于构造函数执行

对象的创建过程： 当new一个对象的时候

  • 在内个存中分配内存空间
  • 对成员变量赋默认值
  • 执行构造代码块或赋值语句，执行顺序从上到下执行
  • 构造函数

静态代码块

使用static修饰的代码构造块，在类加载的时候调用一次，以后不再调用。 通常放置对静态成员的初始化过程

static成员，跟对象无关，访问的方式是通过Class.XXX()

this关键字

this:代表其所在函数所属对象的引用，即this代表类对象的引用

static 关键字

用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点： 随着类的加载而加载 优先于对象存在 被所有的对象所共享 可以直接被类名调用

使用注意： 静态方法只能访问静态成员 静态方法不能写this,super关键字 主函数是静态的

代码例子如下：

  1. package study_java.ex01;
  2.  
  3. public class StaticDemo1 {
  4.     public static void main(String[] args){
  5.         System.out.println(Benz.brand1);
  6.  
  7.         Benz b1 = new Benz();
  8.         System.out.println(b1.getBrand());
  9.  
  10.         // 直接访问静态方法
  11.         System.out.println(Benz.getBrand1());
  12.     }
  13. }
  14.  
  15. class Benz{
  16.     // 静态成员
  17.     private static String brand = "BENZ";
  18.  
  19.     public static  String brand1 = "BENZ1";
  20.  
  21.     private String color;
  22.  
  23.     public void setColor(String color){
  24.         this.color = color;
  25.     }
  26.  
  27.     public String getBrand(){
  28.         return brand;
  29.     }
  30.  
  31.     public static String getBrand1(){
  32.         return brand;
  33.     }
  34. }

this(): 调用其他构造函数的方式，而且必须作为第一条语句

继承

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

多个类可以称为子类，单独这个类称为父类 子类可以直接访问父类中国非私有的属性和方法 通过extends关键字让类与类之间产生继承 java中只支持单冲继承 + 多层继承

简单的例子：

  1. package study_java.ex01;
  2.  
  3. public class ExtendsDemo1 {
  4.  
  5.     public static void main(String[] args){
  6.         JingBa jingba = new JingBa();
  7.         jingba.name = "大黄";
  8.         jingba.watch();
  9.         jingba.owner="zz";
  10.     }
  11.  
  12. }
  13.  
  14. class Animal{
  15.     public String name;
  16.     public int weight;
  17.     public void move(){
  18.         System.out.println("move.....");
  19.     }
  20. }
  21.  
  22. class Dog extends Animal{
  23.     public void watch(){
  24.         System.out.println("有人来了");
  25.     }
  26. }
  27.  
  28. class JingBa extends Dog{
  29.     public String owner;
  30. }

super关键字

调用的是父类的构造函数，必须是第一条语句 通过下面例子理解：

  1. package study_java.ex01;
  2.  
  3. public class ExtendsDemo2 {
  4.  
  5.     public static void main(String[] args){
  6.         // 创建对象
  7.         BMWSportCar mychar = new BMWSportCar();
  8.         mychar.color = "red";
  9.         mychar.velocity = 200;
  10.         mychar.price = 20000;
  11.         mychar.run();
  12.  
  13.     }
  14. }
  15.  
  16. class Car{
  17.     public String color;
  18.     public void run(){
  19.         System.out.println("running.....");
  20.     }
  21.  
  22.     public Car(String color){
  23.         this.color = color;
  24.         System.out.println("new car("+color+")");
  25.     }
  26. }
  27.  
  28. class SportCar extends Car{
  29.     public int velocity;
  30.     public SportCar(int velocity){
  31.         super("yellow");
  32.         this.velocity = velocity;
  33.         System.out.println("new SportCar("+velocity +")");
  34.     }
  35. }
  36.  
  37. class BMWSportCar extends SportCar{
  38.     public int price;
  39.  
  40.     public BMWSportCar(){
  41.         super(200);
  42.         System.out.println("new BMWSportCar");
  43.     }
  44. }

如果被继承的父类的属性是私有的，如果想要访问或者更改，可以通过定义公有的方法来实现，代码例子如下：

  1. package study_java.ex01;
  2.  
  3. public class ExtendsDemo2 {
  4.  
  5.     public static void main(String[] args){
  6.         // 创建对象
  7.         BMWSportCar mychar = new BMWSportCar();
  8.         mychar.setColor("red");
  9.         mychar.velocity = 200;
  10.         mychar.price = 20000;
  11.         mychar.run();
  12.         System.out.println(mychar.getColor());
  13.  
  14.     }
  15. }
  16.  
  17. class Car{
  18.     //私有属性
  19.     private String color;
  20.     public void run(){
  21.         System.out.println("running.....");
  22.     }
  23.  
  24.     public Car(){
  25.  
  26.         System.out.println("new car()");
  27.     }
  28.     // 公有方法
  29.     public String getColor(){
  30.         return color;
  31.     }
  32.     public void setColor(String color){
  33.         this.color = color;
  34.     }
  35. }
  36.  
  37. class SportCar extends Car{
  38.     public int velocity;
  39.     public SportCar(){
  40.         System.out.println("new SportCar()");
  41.     }
  42. }
  43.  
  44. class BMWSportCar extends SportCar{
  45.     public int price;
  46.  
  47.     public BMWSportCar(){
  48.         System.out.println("new BMWSportCar");
  49.     }
  50. }

super和this的用法有点相似

  • this代表本类对象的引用
  • super代表父类的内存空间的标识
  • 子类要调用父类构造函数时，可以使用super()语句
  • 当子类和父类出现同名成员时，可以用super进行区分

super()和this()

调用父类的构造函数，必须是第一条语句

  1. package study_java.ex01;
  2.  
  3. public class ExtendsDemo2 {
  4.  
  5.     public static void main(String[] args){
  6.         // 创建对象
  7.         BMWSportCar mychar = new BMWSportCar();
  8.         mychar.setColor("red");
  9.         mychar.velocity = 200;
  10.         mychar.price = 20000;
  11.         mychar.run();
  12.         System.out.println(mychar.getColor());
  13.  
  14.     }
  15. }
  16.  
  17. class Car{
  18.     //私有属性
  19.     private String color;
  20.     public void run(){
  21.         System.out.println("running.....");
  22.     }
  23.  
  24.     public Car(){
  25.  
  26.         System.out.println("new car()");
  27.     }
  28.     // 公有方法
  29.     public String getColor(){
  30.         return color;
  31.     }
  32.     public void setColor(String color){
  33.         this.color = color;
  34.     }
  35. }
  36.  
  37. class SportCar extends Car{
  38.     public int velocity;
  39.     public SportCar(){
  40.         System.out.println("new SportCar()");
  41.     }
  42.     public void setColorPro(String color){
  43.         // this.color = color;  //这里和下面的的super是一样的
  44.         super.setColor(color);
  45.     }
  46.  
  47.     public void setColor(String color){
  48.         super.setColor(color);
  49.     }
  50.  
  51. }
  52.  
  53. class BMWSportCar extends SportCar{
  54.     public int price;
  55.  
  56.     public BMWSportCar(){
  57.         System.out.println("new BMWSportCar");
  58.     }
  59. }

任何一个对象的创建都包含整个家族簇的创建，任何一个成员的创建，都包含这一整个顺序的完成 通过下面代码理解这个过程

  1. package study_java.ex01;
  2.  
  3. public class ExtendsDemo3 {
  4.     public static void main(String[] args){
  5.         // 创建对象
  6.         BMWSportCar mychar = new BMWSportCar();
  7.         mychar.setColor("red");
  8.         mychar.velocity = 200;
  9.         mychar.price = 20000;
  10.         mychar.run();
  11.         System.out.println(mychar.getColor());
  12.  
  13.     }
  14. }
  15.  
  16. class Car{
  17.     //私有属性
  18.     private String color;
  19.  
  20.     {
  21.         System.out.println("Cons Block in Car");
  22.     }
  23.  
  24.     public void run(){
  25.         System.out.println("running.....");
  26.     }
  27.  
  28.     public Car(){
  29.  
  30.         System.out.println("new car()");
  31.     }
  32.     // 公有方法
  33.     public String getColor(){
  34.         return color;
  35.     }
  36.     public void setColor(String color){
  37.         this.color = color;
  38.     }
  39. }
  40.  
  41. class SportCar extends Car{
  42.     public int velocity;
  43.  
  44.     {
  45.         System.out.println("Cons Block in SportCar");
  46.     }
  47.     public SportCar(){
  48.         System.out.println("new SportCar()");
  49.     }
  50.     public void setColor(String color){
  51.         super.setColor(color);
  52.     }
  53.  
  54. }
  55.  
  56. class BMWSportCar extends SportCar{
  57.     public int price;
  58.  
  59.     public BMWSportCar(){
  60.         System.out.println("new BMWSportCar");
  61.     }
  62. }

函数覆盖

子类中出现与父类中一模一样的方法时，会出现覆盖操作，也称为重写或者复写 父类中的私有方法不可以被覆盖 在子类覆盖方法中，继续使用被覆盖的方法可以通过super函数名获取

覆盖时需要注意的问题： 覆盖时，子类方法权限一定要大于等于父类方法权限 静态只能覆盖静态

主要的应用是： 当子类需要父类的功能，而功能主题子类有自己特有的内容时，可以复写父类中的方法，这样就既沿袭了父类 的功能，又定义了父类特有的内容

代码例子：

  1. package study_java.ex01;
  2.  
  3. public class OverrideDemo1 {
  4.     public static void main(String[] args){
  5.         Rich2Man s2 = new Rich2Man();
  6.         s2.consume(200000);
  7.     }
  8. }
  9.  
  10. class RichMan{
  11.     public void consume(int money){
  12.         if(money < 500){
  13.             System.out.println("消费了"+money+"w");
  14.         }
  15.         else {
  16.             System.out.println("不能消费了");
  17.         }
  18.  
  19.     }
  20. }
  21.  
  22. class Rich2Man extends RichMan{
  23.     public void consume(int money){
  24.         if(money < 50000){
  25.             System.out.println("消费了"+money+"w");
  26.         }
  27.         else {
  28.             System.out.println("不能消费了");
  29.         }
  30.  
  31.     }
  32. }

子类的实例化过程

子类中所有的构造函数morning都会访问父类中空参数的构造函数 因为每一个构造函数的第一行都有一条默认的语句super() 子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。 当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数

final 关键字

final 可以修饰类，方法和变量

final 修饰的类不可以被继承

final 修饰的方法不可以被覆盖(可以继承)

final 修饰的变量是一个常量只能被赋值一次

内部类只能访问被final修饰的局部变量

  1. package study_java.ex01;
  2.  
  3. public class FinalDemo1 {
  4.     public static void main(String[] args){
  5.         Jing8 j = new Jing8();
  6.         j.watch();
  7.         System.out.println(j.name);
  8.     }
  9. }
  10.  
  11. class Dog1{
  12.     // 常量
  13.     public final String name = "aaa";
  14.  
  15.     // final 修饰的方法不能重写
  16.     public /*final */ void watch(){
  17.         System.out.println("来人了");
  18.     }
  19. }
  20.  
  21. class Jing8 extends Dog1{
  22.     public void watch() {
  23.         System.out.println("听一听");
  24.         super.watch();
  25.     }
  26. }

关于内部类 定义在class内部的类 编译产生OuterClass$Innerc.class 内部类访问外部类的局部变量，需要final修饰

代码例子：

  1. package study_java.ex01;
  2.  
  3. public class InnerClassDemo {
  4.     public static void main(String[] args){
  5.         Car2 c = new Car2();
  6.         c.run();
  7.     }
  8. }
  9.  
  10. class Car2{
  11.     public String color = "red";
  12.     public int tires;
  13.  
  14.     public void run(){
  15.         new Engine().fire();
  16.         System.out.println("running.....");
  17.     }
  18.  
  19.     class Engine{
  20.         public void fire(){
  21.             System.out.println("fire");
  22.         }
  23.     }
  24. }

但是如果内部类写在了方法里，这里有一个问题需要注意：

  1. public class InnerClassDemo {
  2.     public static void main(String[] args){
  3.         Car2 c = new Car2();
  4.         c.run();
  5.     }
  6. }
  7.  
  8. class Car2{
  9.     public String color = "red";
  10.     public int tires;
  11.  
  12.     public void run(){
  13.         // 这里的key必须是final 字段
  14.         final String key = "ss";
  15.         class Engine{
  16.             public void fire(){
  17.                 System.out.println("插入钥匙"+key);
  18.                 System.out.println("fire");
  19.             }
  20.         }
  21.         new Engine().fire();
  22.         System.out.println("running.....");
  23.     }
  24.  
  25. }

抽象类

抽象类的定义： 抽象就是从多个事物中将共性的，本质的内容抽取出来 java 中可以定义没有方法体的方法，该方法的具体实现交给子类完成该 方法称为抽象方法，包含抽象方法的类就是抽象类

抽象类和抽象方法必须用abstract关键字修饰 抽象方法只有方法声明，没有具体的方法体，定义在抽象类中 抽象类不可以被实例化，也就是不能用new创建对象 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的方法后才可以创建对象，否则该子类也是抽象类

Java基础（二）面向对象（上）的更多相关文章

  1. 【Java基础】面向对象上

    面向对象上 这一章主要涉及 Java 类及类的成员,包括属性.方法.构造器:代码块.内部类. 面向过程与面向对象 面向过程(Procedure Oriented Programming,POP)与面向 ...

  2. Java入土--Java基础(二)

    Java基础(二) 接上一讲,我们接着来聊聊Java的一些基础知识,下一讲就会进行流程的控制. 类型转换 首先呢,是类型的转换,接上一个内容的数据类型,类型转换就是数据类型更进一步的应用. 由于Jav ...

  3. 20175212童皓桢 Java实验二-面向对象程序设计实验报告

    20175212童皓桢 Java实验二-面向对象程序设计实验报告 实验内容 初步掌握单元测试和TDD 理解并掌握面向对象三要素:封装.继承.多态 初步掌握UML建模 熟悉S.O.L.I.D原则 了解设 ...

  4. Java基础-初识面向对象编程（Object-Oriented-Programming）

    Java基础-初识面向对象编程(Object-Oriented-Programming) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. Java是一门面向对象的程序设计语言.那么什 ...

  5. Java面试题总结之Java基础(二)

    Java面试题总结之Java基础(二) 1.写clone()方法时,通常都有一行代码,是什么? 答:super.clone(),他负责产生正确大小的空间,并逐位复制. 2.GC 是什么? 为什么要有G ...

  6. 黑马程序员——【Java基础】——面向对象（二）异常机制、包（Package）

    ---------- android培训.java培训.期待与您交流! ---------- 一.异常机制 (一)异常概述 1.异常:就是程序在运行时出现不正常情况. 2.异常类:程序在运行时,出现的 ...

  7. Java基础知识【上】(转载)

    http://blog.csdn.net/silentbalanceyh/article/details/4608272 (最终还是决定重新写一份Java基础相关的内容,原来因为在写这一个章节的时候没 ...

  8. Java基础(二) 基本类型数据类型、包装类及自动拆装箱

    我们知道基本数据类型包括byte, short, int, long, float, double, char, boolean,对应的包装类分别是Byte, Short, Integer, Long ...

  9. 最新28道java基础面试题-上

    28道java基础面试题 1.面向对象的特征有哪些方面? 答:面向对象的特征主要有以下几个方面: 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面.抽象只关注对象有哪 ...

  10. java基础(二)-----java的三大特性之继承

    在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句 ...

随机推荐

  1. linux基础 用户（组）管理

    修改/etc/shadow文件 1.chage -m MINDAYS USERNAME#设置密码修改最小天数2.chage -M MAXDAYS USERNAME#设置密码修改最大天数3.chage ...

  2. ubantu16.04安装sougou输入法

     安装搜狗拼音输入法下载安装包:http://pinyin.sogou.com/linux/?r=pinyin如果直接安装不了,则按如下方法进行安装:sudo dpkg -i sogoupinyin_ ...

  3. visual studio 加入zen-codding

    大家都知道zen codding的强大之处大家都知道了,那如何让visual studio也支持呢,直接下载插件安装即可: 插件下载地址:zen-codding for visual studio下载 ...

  4. BZOJ.4337.[BJOI2015]树的同构(树哈希)

    BZOJ 洛谷 \(Description\) 给定\(n\)棵无根树.对每棵树,输出与它同构的树的最小编号. \(n及每棵树的点数\leq 50\). \(Solution\) 对于一棵无根树,它的 ...

  5. WordPress UpdraftPlus插件 Google Drive 备份

    本文连接地址: http://blog.tuzhuke.info/?p=168 本文作者:tuzhuke 完成时间:2015-04-10 使用wordpress 搭建自己的博客网站,但是对于租用的服务 ...

  6. [JOISC2014]ストラップ

    [JOISC2014]ストラップ 题目大意: 有\(n(n\le2000)\)个挂饰,每个挂饰有一个喜悦值\(b_i(|b_i|\le10^6)\),下面有\(b_i(b_i\le10^6)\)个挂钩 ...

  7. BZOJ1897 : tank 坦克游戏

    设$f[i][j][k]$表示坦克位于$(i,j)$,目前打了不超过$k$个位置的最大得分. 初始值$f[1][1][k]$为在$(1,1)$射程内最大$k$个位置的分数总和. 对于每次移动,会新增一 ...

  8. shell脚本8--录制终端会话

    准备: script -t 2> timing.log -a output.session type commands; ... . .. exit 回放: scriptreplay timin ...

  9. 分金币 [CQOI 2011] [BZOJ 3293]

    Description 圆桌上坐着n个人,每人有一定数量的金币,金币总数能被n整除.每个人可以给他左右相邻的人一些金币,最终使得每个人的金币数目相等.你的任务是求出被转手的金币数量的最小值. Inpu ...

  10. 使用8.0版本jdbc驱动连接数据库操作

    转自:https://blog.csdn.net/qq_41734885/article/details/80562815 首先,我居然不能用navicat客户端连接上mysql8.0数据库报1251 ...