java面向对象编程难吗,java 面向对象编程

什么是面向对象

回顾方法的定义与调用

方法的定义

import java.io.IOException;//Demo01 类public class Demo01 { //main方法 public static void main(String[] args) { } public String sayHello(){ return "helloWorld"; } public void readFile(String file) throws IOException{ }}

方法的调用

public class Demo02 { public static void main(String[] args) { //非静态方法这样 new Student().say(); //或者 Student student=new Student(); student.say(); } //static 的方法是和类一起加载的，存在较早 public static void a(){ // b(); //这里会报错，不能调用!!!!!!! } //类实例化之后才存在 public void b(){ }}

//值传递public class Demo03 { public static void main(String[] args) { int a=1; System.out.println(a);//1 change(a); System.out.println(a);//1 } //返回值为空 public static void change(int a){ a=10; }}

//引用传递: 传递的对象，本质还是值传递//对象要理解透彻、内存要理解透彻！！！！！！！！public class Demo04 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name);//null change(person); System.out.println(person.name);//wda } public static void change(Person person){ //person 是一个对象：指向的--》Person person = new Person(); 这是一个具体的人可以改变属性 person.name ="wda"; }}//定义了一个Person类，有一个属性class Person{ String name;//null}

类与对象的创建

public class Student { //属性；字段 String name;//null int age;//0 //方法 public void study(){ System.out.println(this.name+"在学习"); }}/*public static void main(String[] args) { //类：抽象的，需要实例化 //类实例化后会返回一个自己的对象！ Student xiaoming = new Student(); Student xiaohong = new Student(); xiaoming.age=3; xiaoming.name="ming"; System.out.println(xiaoming.name); System.out.println(xiaoming.age); } */

构造器详解

package com.oop.demo02;//java-->会生成一个class文件public class Person { //一个类即使什么都不写，也会存在一个方法 //显式的定义构造器 String name; int age; //构造器的功能 //实例化初始值 //1.使用new关键字，本质是在调用构造器 //2.用来初始化值 public Person(){ this.name="safa"; } //有参构造器:一旦定义了有参构造，无参就必须显式定义 public Person(String name){ this.name=name; } //alt+ insert 快捷定义构造器}/*public static void main(String[] args) { //new 实例化了一个对象 Person person = new Person("aaa"); System.out.println(person.name); //aaa } 构造器： 1.和类名相同 2.没有返回值 作用： 1.使用new关键字，本质是在调用构造器 2.用来初始化值 注意点： 1.一旦定义了有参构造，如果想使用无参构造，无参就必须显式定义 alt+ insert 快捷定义构造器 this.= */

创建对象内存分析

package com.oop.demo03;public class Pet { public String name; public int age; //无参构造 public void shout(){ System.out.println("叫了一声");; }}/*public static void main(String[] args) { Pet dog = new Pet(); dog.name="wangcai"; dog.age=3; dog.shout(); System.out.println(dog.name); System.out.println(dog.age); Pet cat = new Pet(); } */

封装详解

package com.oop.demo04;//private 私有public class Student { //封装大多数时候是对属性来说的，方法里面用的比较少 /* 1.提高程序的安全性 2.隐藏代码的实现细节 3.统一接口 4.系统可维护性增加了 */ // 名字 //属性私有 private String name; //学号 private int id; //性别 private char sex; //年龄 private int age; //提供一些可以操作这个属性的方法 //提供一些pubLicde的get、set方法 //get 获得这个数据 public String getName(){ return this.name; } //set 给这个数据设置值 public void setName(String name){ this.name=name; } public int getAge() { return age; } public void setAge(int age) { if(age>120||age<0){ this.age = 3; }else { this.age=age; } } //学习() //睡觉()}/*public static void main(String[] args) { Student s1 =new Student(); // s1.name 会报错 s1.setName("sfa"); s1.getName(); //alt + insert 可以智能生成get set!!!!!!!!!! s1.setAge(999);//不合法的 System.out.println(s1.getAge()); } */

继承

基础

package com.oop;import com.oop.demo05.Student;public class Application { public static void main(String[] args) { Student student =new Student(); student.say(); System.out.println(student.money); //System.out.println(student.money_private); //报错，说明父类私有的属性不能继承 }}

package com.oop.demo05;//在Java中，所有的类，都默认直接或间接继承object类//人 父类public class Person /*extends Object*/{ //public //protected //default //private public int money =10_0000_0000; private int money_private=10; public void say(){ System.out.println("说了一句话"); }}

package com.oop.demo05;//学生 is 人 派生类//子类继承了父类，就会拥有父类的全部方法！！！public class Student extends Person{ //ctrl+h 打开继承树！！！！！！}

package com.oop.demo05;//Teacher is Person 派生类public class Teacher extends Person{}

super详解

package com.oop;import com.oop.demo05.Student;public class Application { public static void main(String[] args) { Student student =new Student(); //Person无参构造执行了 //Student 无参执行了 //student.test("aa"); student.test1(); }}

package com.oop.demo05;//在Java中，所有的类，都默认直接或间接继承object类//人 父类public class Person /*extends Object*/{ //public //protected //default //private public int money =10_0000_0000; private int money_private=10; protected String name="ks"; //public-->private则出错，私有的东西无法继承 public void print(){ System.out.println("person"); } public void say(){ System.out.println("说了一句话"); } public Person() { System.out.println("Person无参构造执行了"); }}

package com.oop.demo05;//学生 is 人 派生类//子类继承了父类，就会拥有父类的全部方法！！！public class Student extends Person{ //ctrl+h 打开继承树！！！！！！ private String name="qj"; public void test(String name){ System.out.println(name);//aa System.out.println(this.name);//qj System.out.println(super.name);//ks } public void print(){ System.out.println("Student"); } public void test1(){ print();//Student this.print();//Student super.print();//person } public Student() { //隐藏代码，默认调用了父类的无参构造！！！！！！！！！！ super();//调用父类的构造器，必须要在子类构造器第一行 System.out.println("Student 无参执行了"); }}

super注意点： 1.super调用父类的构造方法，必须在构造方法的第一行 2.super必须只能出现在子类的方法或者构造方法中！ 3.super和this不能同时调用构造方法vs this: 代表的对象不同： this：本身调用者这个对象 super：代表父类对象的应用 前提： this：没有继承也可以使用 super：只能在继承条件才可以使用 构造方法 this();本类的构造 super();父类的构造

方法重写

package com.oop.demo05;//继承public class A extends B{ @Override //注解：有功能的注释 public void test() { System.out.println("A->test()"); }}

package com.oop.demo05;//重写都是方法的重写，和属性无关public class B { public void test(){ System.out.println("B->test()"); }}

package com.oop;import com.oop.demo05.A;import com.oop.demo05.B;public class Application { public static void main(String[] args) { //静态的方法和非静态的方法区别很大 //静态方法：方法的调用只和左边，定义的数据类型有关 //只有非静态才叫做重写 ，private也不可以，只有public才可以 .........