面向对象，呃，别给我说程序员找不到对象，那是windows才会出现的情况~~~

　　就简单记下笔记什么的吧。

1、关于定义和赋值

　　之前总是搞混淆，说到底是没有搞清楚。

shit bigOne=new shit();

　类型   变量名   定义

　　所以应该是先写后面——定义——new 类名();然后是前面，赋值给一个变量；然后最前面，该变量的数据类型，这里，数据类型就是该类。

2、局部变量和成员变量

　　遵循就近原则，即局部变量和成员变量重复时，以局部变量为准。

3、关于构造方法

　　其实上面定义对象的时候，最后面那个不是变量，不是类，是该类的构造方法！！！

　　所以有参的对象定义，也就是在有参的构造函数的调用。

　　所以可以直接通过有参构造函数进行输入，同时可以进行输入控制——安全性，正确性等。

　　另外，关于有参和无参并存：

package imooc2;public class telephone {//属性double size;String color;double cpu;double price;//方法void sendMessage(){System.out.println("Shit!"+size+color+cpu+price);}public telephone(){System.out.println("无参构造方法执行！");}public telephone(double sizeIn,String colorIn,double cpuIn,double priceIn){size=sizeIn;color=colorIn;cpu=cpuIn;price=priceIn;System.out.println("有参构造方法执行");}}

package imooc2;public class initialTelephone {public static void main(String[] args) {// TODO Auto-generated method stubtelephone phone = new telephone(1,"black",2.3,1500);phone.sendMessage();phone.color="white";phone.cpu = 1.3;phone.sendMessage();telephone phone2 = new telephone();phone2.sendMessage();}
}

4、关于静态变量

　　静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收。

　　同样，静态方法也会有特殊情况：

　　

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如：

运行结果：

需要注意：

1） 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如：

2） 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

3） 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。如：

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如：

运行结果：

需要注意：

1）静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如：

2） 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

3） 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

public class HelloWorld {// 定义静态变量score1static int score1 = 86;// 定义静态变量score2static int score2 = 92; // 定义静态方法sum，计算成绩总分，并返回总分public   static  int sum() { int sum = score1+score2;return sum;      }public static void main(String[] args) {        // 调用静态方法sum并接收返回值int allScore = HelloWorld.sum();        System.out.println("总分：" + allScore);}
}


5、关于静态初始化块

　　这个我也是第一次知道，有点好玩，也是初始化块——》静态初始化块的

public class HelloWorld {String name; // 声明变量nameString sex; // 声明变量sexstatic int age;// 声明静态变量age// 构造方法public  HelloWorld() { System.out.println("通过构造方法初始化name");name = "tom";}// 初始化块
    { System.out.println("通过初始化块初始化sex");sex = "男";}// 静态初始化块static { System.out.println("通过静态初始化块初始化age");age = 20;}public void show() {System.out.println("姓名：" + name + "，性别：" + sex + "，年龄：" + age);}public static void main(String[] args) {// 创建对象HelloWorld hello = new HelloWorld();// 调用对象的show方法
        hello.show();}
}

　　通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。

　　需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

6、关于封装

　　对象的三大特性：封装、继承和多态！

　　封装：封装是个动词，动词就有对象，这里的对象就是对象，也就是把对象进行封装。什么叫做对象的封装呢？就是外部不能直接访问内部属性。类比电子元器件的封装，也就是用户只能通过接口插口等对其进行访问，不能直接接触其中的元器件。

　　好处自然不用说。

　　另外，封装三大步：private属性——》set和get方法设定——》输入输出控制；

package imooc2;public class telephone {//属性private double size;private String color;private double cpu;private double price;//方法public double getSize(){return size;}public void setSize(double sizeInput){size=sizeInput;}public String getColor(){return color;}public void setColor(String colorInput){color=colorInput;}void sendMessage(){System.out.println("Shit!"+size+color+cpu+price);}public telephone(){System.out.println("无参构造方法执行！");}public telephone(double sizeIn,String colorIn,double cpuIn,double priceIn){size=sizeIn;color=colorIn;cpu=cpuIn;price=priceIn;System.out.println("有参构造方法执行");}}

7、关于包

　　包也可以看成是一种封装，只不过对象是各种类，也就是说包是各种类的文件夹。

　　包的存在是重名问题得到解决——比如你我都有一个姐姐，但定义一个类文件的时候，重名的是不能出现在同一个包的，所以有子包等概念出现。

　　这里就可以有两个telephone.java；

　　调用的话，就在头输入import即可

package com.imooc;
import com.imooc.second.telephone;

8、访问修饰符

一图以敝之

9、关于this关键字

　　this表示当前对象，于是setter和getter中就经常使用this了。

　　另外，eclipse中自带生成setter和getter。

　　于是

public double getCpu() {return cpu;}public void setCpu(double cpu) {this.cpu = cpu;}

10、关于内部类

　　即类中类，关键就是用一个关键字Inner

//外部类HelloWorld
public class HelloWorld {// 内部类Inner，类Inner在类HelloWorld的内部public class Inner {// 内部类的方法public void show() {System.out.println("welcome to imooc!");}}public static void main(String[] args) {// 创建外部类对象HelloWorld hello = new HelloWorld();// 创建内部类对象Inner i = hello.new Inner();// 调用内部类对象的方法
        i.show();}
}

　　内部类的存在原因是更好的封装

//外部类HelloWorld
public class HelloWorld{//外部类的私有属性nameprivate String name = "imooc";//外部类的成员属性int age = 20;//成员内部类Innerpublic class Inner {String name = "爱慕课";//内部类中的方法public void show() { System.out.println("外部类中的name：" + HelloWorld.this.name );System.out.println("内部类中的name：" +    name              );System.out.println("外部类中的age：" + age);}}//测试成员内部类public static void main(String[] args) {//创建外部类的对象HelloWorld o = new HelloWorld (); //创建内部类的对象Inner inn =   o.new Inner()           ;//调用内部类对象的show方法
        inn.show();}
}

　　以及静态内部类

//外部类
public class HelloWorld {// 外部类中的静态变量scoreprivate static int score = 84;// 创建静态内部类public static class SInner {// 内部类中的变量scoreint score = 91;public void show() {System.out.println("访问外部类中的score：" + HelloWorld.score );System.out.println("访问内部类中的score：" + score);}}// 测试静态内部类public static void main(String[] args) {// 直接创建内部类的对象SInner si = new SInner();// 调用show方法
        si.show();}
}

　　以及方法内部类，也就是方法中定义内部类，有点繁琐，搞清楚调用的过程就行了

//外部类
public class HelloWorld {private String name = "爱慕课";// 外部类中的show方法public void show() { // 定义方法内部类class MInner {int score = 83;public int getScore() {return score + 10;}}// 创建方法内部类的对象MInner mi = new MInner();// 调用内部类的方法
        mi.getScore();System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);}// 测试方法内部类public static void main(String[] args) {// 创建外部类的对象HelloWorld mo = new HelloWorld();// 调用外部类的方法
        mo.show();}
}

11、关于继承

　　就是子类继承父类的属性和方法，说白了就是代码复用，就是程序员懒省事儿，为了代码整洁所做的工作。

　　需要注意父类的private是继承不到的。

　　实际上初始化一个子类对象，是先初始化父类对象的属性和构造方法，然后是子类的属性和构造方法！

　　可以使用super关键词调用父类的方法和属性，注意super无法在static的方法中调用，比如主函数。

12、关于重写

　　重写，也是一个动词，对象就是方法，是父类的方法。

　　就是子类对父类的方法不满意，重新书写该方法。

　　需要注意的是重写要求函数投是要求完全相同的，才能实现重写。

13、final关键字

14、关于Object类

　　所有类在没有强调父类时，默认的父类都是Object类！

　　Object类中有两个常用到的方法，toString()和equals()；前者默认返回对象地址信息，后者默认对比两个对象引用地址是否相同；

　　由于对父类这两个方法不满意，所以我们在子类中进行重写；

　　这两个特殊的重写，直接交给eclipse，方法和上面那个一样，结果如下

package com.jicheng;public class Dog extends Animal {public int age=10;@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)//引用地址return true;if (obj == null)//比较空值return false;if (getClass() != obj.getClass())//类对象，就是把类的情况作为对象，类的类型是否相同return false;Dog other = (Dog) obj;if (age != other.age)//属性值return false;return true;}public void eat(){}@Overridepublic String toString() {return "Dog [age=" + age + "]";}}

主函数

package com.jicheng;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dd=new Dog();System.out.println(dd);Dog dog = new Dog();
//        if(dog==dd){if(dog.equals(dd)){System.out.println("yes");}else{System.out.println("no");}}}

15、关于多态

　　多态，一个形容词，就是说多种形态，那么形容的对象是？是对象。也就是说对象具有多种形态。

　　那么，对象具有多种形态，其实说的是对象的引用和方法具有多种形态

　　直观的看比较抽象，给出代码示例

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubAnimal obj1 = new Animal();Animal obj2 = new Dog();//父类的引用可以指向子类的对象Dog obj3 = new Dog();
//        Dog obj4 = new Animal();//错误
        obj1.eat();obj2.eat();//同样是父类的引用，但指向不同结果不同，称为方法的多态}
}

package com.duotai;public class Animal {public void eat(){System.out.println("Can eat");}
}

package com.duotai;public class Dog extends Animal {public void eat(){System.out.println("Dog eats meat");}
}

16、关于引用类型转换

　　这里出现了父类引用子类的情况，也就是说有引用类型转换的情况了。

　　关于引用类型转换，分为向上转换/隐式转换和向下转换/强制转换；

　　考虑向上转换为把水杯里的水倒回水壶，所以一般都是没有问题的；向下则相反，会出现问题，于是会有强制转换的需求。

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dog = new Dog();Animal animal = dog;//向上转换
//      Dog dog2 = animal;//直接的向下转换，不被允许Dog dog2 = (Dog)animal;//强制的向下转换，可以执行Cat cat = (Cat)animal;//同样可以执行，但会出现编译问题}
}

　　所以，一般使用强制使用的，需要先进行判断，用instanceof

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dog = new Dog();Animal animal = dog;//向上转换if(animal instanceof Dog){Dog dog2 = (Dog)animal;}else{System.out.println("Shit");}if(animal instanceof Cat){Cat cat = (Cat)animal;}else{System.out.println("Shit");}}
}

17、关于抽象类

　　说到引用类型转换，有一个常用的场景：抽象类。

　　抽象对应具体，也就是说抽象的类；抽象类不关注子类的具体实现，只规定子类应该有什么样的方法！！

package com.chouxianglei;public abstract class Telephone {public abstract void call();public abstract void message();
}

　　子类应该继承它

package com.chouxianglei;public class cellPhone extends Telephone {@Overridepublic void call() {// TODO Auto-generated method stubSystem.out.println("键盘打电话");}@Overridepublic void message() {// TODO Auto-generated method stubSystem.out.println("键盘发短信");}
}

　　使用的时候就可以父类引用子类，注意这里父类不能引用自己

package com.chouxianglei;public class initail {public static void main(String[] args) {// TODO Auto-generated method stubTelephone telephone = new cellPhone();telephone.call();Telephone t2 = new smartPhone();t2.call();t2.message();}
}

18、关于接口

　　有了抽象类的概念，就不得不提一下接口的概念。

　　接口和抽象类类似，都是一种规范，但更加灵活，更加省事儿——比如有相同特征的，就可以针对相同特征设立接口，接口可以对接多个父接口，接口中都是abstract的，但不需要自己进行书写；

　　所以举例子，PSP和智能手机都有玩游戏的特征，但智能手机继承自手机父类，PSP继承自游戏机父类，但共同的特征是一个接口

package com.chouxianglei;public interface IPlayGame {public void playGame();
}

　　注意：接口的命名一般以I开头，以和其他类进行区分；

package com.chouxianglei;public class PSP implements IPlayGame {@Overridepublic void playGame() {// TODO Auto-generated method stubSystem.out.println("PSP可以玩游戏");}
}

　　有父类的一定写在接口前面

package com.chouxianglei;public class smartPhone extends Telephone implements IPlayGame{@Overridepublic void call() {// TODO Auto-generated method stubSystem.out.println("触摸屏打电话");}@Overridepublic void message() {// TODO Auto-generated method stubSystem.out.println("触摸屏发短信");}public void playGame(){System.out.println("手机可以玩游戏");}
}

　　引用中，接口还是看成是父类的，依然可以父类引用子类

package com.chouxianglei;public class initail {public static void main(String[] args) {// TODO Auto-generated method stubTelephone telephone = new cellPhone();telephone.call();Telephone t2 = new smartPhone();t2.call();t2.message();IPlayGame psp = new PSP();psp.playGame();IPlayGame s1 = new smartPhone();s1.playGame();//匿名内部类IPlayGame tt = new IPlayGame(){public void playGame(){System.out.println("匿名内部类使用");}            };tt.playGame();new IPlayGame(){public void playGame(){System.out.println("匿名内部类使用2");}}.playGame();}}

　　最后两段是匿名内部类，即在程序中直接进行定义的类，直接使用！

19、关于UML

　　初级的程序员能看懂这种设计类图形语言就行了！

　　常见三种图：类图，用例图，序列图。

　　TMUML还能直接生成语言，天。。。

　　可以用visio画图http://blog.csdn.net/hyman_c/article/details/52586241

　　

转载于:https://www.cnblogs.com/andy1202go/p/6756816.html

Java之关于面向对象相关推荐

  1. [Java入门笔记] 面向对象编程基础（二）：方法详解

    2019独角兽企业重金招聘Python工程师标准>>> 什么是方法? 简介 在上一篇的blog中,我们知道了方法是类中的一个组成部分,是类或对象的行为特征的抽象. 无论是从语法和功能 ...

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

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

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

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

  4. java基础(一)-面向对象思想

    前言 java是一门面向对象的语言,在学习java前,先要理解面向对象这个概念,区别于c这类的面向过程语言,面向对象有着什么一样的特点呢?先上一张思维导图吧: 对象 什么是对象 问题空间中的元素及其在 ...

  5. 电大java语言与面向对象程序设计基础_6406Java语言与面向对象程序设计基础A卷...

    6406Java语言与面向对象程序设计基础A卷 试卷编号:6406 座位号 浙江广播电视大学2006年春季学期开放教育专科期末考试 <Java语言与面向对象程序设计基础>试题 2006年7 ...

  6. 学java教程之面向对象(四)

    学编程吧学java教程之面向对象(四)发布了,欢迎通过xuebiancheng8.com来访问 本次课来分析java面向对象之构造方法.什么是构造方法呢,构造方法听名字顾名思义,构造的时候执行的方法就 ...

  7. Java基础之面向对象的概念 继承---组合----枚举类

    Java基础之面向对象的概念 继承---组合----枚举类 本章作为面向对象概念的最后一篇,但是作为一名java程序员在面向对象的这条路上还很长. 一.继承与组合简介 继承是实现类重用的重要手段,但是 ...

  8. 【java】java学习笔记之java oop（面向对象）

    如下图所示为笔者总结的java oop(面向对象)学习笔记,其中,附带有代码示例(未展开),方便理解记忆.需要源文件的请到我的资源中下载,下载地址:https://download.csdn.net/ ...

  9. JAVA基础：面向对象的例外处理

    为初学者而著! Java基础是初学者的起点,是帮助你从小白入门到精通必学基础课程! B站最新录制Java300集>>>   适合准备入行开发的零基础员学习Java,基于最新JDK13 ...

  10. java饲养员喂动物_做一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口（抽象类）的用处...

    做一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口(抽象类)的用处 interface Animal{ //动物的接口    public void eat(Food food); // ...

最新文章

  1. Gitlab Webhooks, External Services, and API(一)
  2. 演练：使用 TableLayoutPanel 在 Windows 窗体上排列控件
  3. 数据库：B+树索引和Hash索引得区别
  4. JSONP原理以及安全问题
  5. 数据库系统的三级模式结构知识笔记
  6. L2-014 列车调度（队列模拟:set）
  7. Python 自动化，Helium 凭什么取代 Selenium？
  8. 科技公司都是如何应对 COVID-19？
  9. Emacs-224-彩虹猫的实现
  10. 909422229_Mysql创建序列
  11. Linux如何强制关闭任务进程（Linux版任务管理器）
  12. 112-smart-toc-2021-09-09
  13. 一个大牛的acm历程（看着就要颤抖
  14. Vue.js + Vuex + TypeScript 实战项目开发与项目优化
  15. 在中国，混哪个“圈子”最有“钱”途？
  16. 自学虚幻引擎图文笔记：颜色混合、法线强度调整及选择、归一化、点积、常量偏差比例、规范化等节点
  17. 诚邀参加“认知与路径：元宇宙科技传播”线上专题研讨会
  18. 开源中国iOS客户端学习——(十二)用户登陆
  19. python批量删除微信好友_我用Python找出了删除我微信的所有人并将他们自动化删除了...
  20. 光耦继电器工作原理与参数详解

热门文章

  1. K8S 基本架构与常用术语
  2. Scala模式匹配：变量声明中的模式匹配
  3. scala为什么需要函数
  4. Python Django 设置和获取Cookie代码示例
  5. Spring MVC HttpMessageConverter对象
  6. 关于齐次坐标的理解记录
  7. stateflow新建状态中的枚举类型
  8. 17章 SPI控制器（XIlinx ZYNQ-7000 SOC UG-585文档）
  9. SourceInsight 4.0 之三 常用宏使用、编辑、修改详解（附最新完善版本的宏）
  10. layui table勾选框的修改_layui怎么设置checkbox勾选