公司网站建设包括,如何用网站做推广,一条龙网站建设价格,尼高品牌设计8 面向对象
面向对象编程的本质就是#xff1a;以类的方法组织代码#xff0c;以对象的组织#xff08;封装#xff09;数据。 8.1 方法的回顾
package com.oop.demo01;// Demo01 类
public class Demo01 {// main方法public static void main(String[] args) {int c 10…8 面向对象
面向对象编程的本质就是以类的方法组织代码以对象的组织封装数据。 8.1 方法的回顾
package com.oop.demo01;// Demo01 类
public class Demo01 {// main方法public static void main(String[] args) {int c 10;int d 90;System.out.println(max(c,d));sayHello();}/*修饰符 返回值类型 方法名(...){// 方法体return 放回值}*/// return 结束方法返回一个结果!public static String sayHello(){return Hello,world;}public static int max(int a,int b){return ab ? a : b; // 三元运算符}} 如果没有返回值在方法中的话结果就会如下这段代码所示
package com.oop.demo01;// 值传递
public class Demo04 {public static void main(String[] args) {int a 1;// a 的值始终没有改变过都还是1System.out.println(a); // 1change(a);System.out.println(a); // 1}// 返回值为空public static void change(int a){a 10;}
}8.2 类与对象的创建、基础使用 关于类的创建就是直接在IDEA中的文件下直接创建类就是点Java的文件进行编译以后就是点class的文件。创造对象就是对象类型 对象名 对象值。 我是这样理解的 类就可以看做一个做蛋糕的模具而对象就是按照这个模具所做出来的一个个蛋糕蛋糕可以外表一样但是名字可以不一样。比如都是用Student这个类来创建对象。却可以有 Student S1 new Student(); Student S2 new Student(); Student S3 new Student();........................等等
package com.oop.demo01;public class Demo02 {// 静态方法// 非静态方法public static void main(String[] args) {//实例化这个类// 对象类型 对象名 对象值Student student new Student();student.say();}// 有static就是和类一起加载的public static void a(){//c(); --这里的方法如果调用的话会直接报错。/*因为被static修饰过的方法是和类一起加载的而他所调用的这个方法没有被static修饰所以在实例化之后才存在。*/}// 类实例化之后才存在public void c(){}
}可以在类里面再创建一个类并且在里面的类里调用其他的类如下面这段代码
package com.oop.demo01;// 引用传递对象本质还是值传递
public class Demo05 {public static void main(String[] args) {Perosn perosn new Perosn();System.out.println(perosn.name); // nullchange(perosn); // 调用了方法changeSystem.out.println(perosn.name); // 周某}public static void change(Perosn perosn){// perosn是一个类指向的--- Perosn perosn new Perosn();这是一个具体的人可以改变属性perosn.name 周某;}
}//定义了一个Perosn类有一个属性name
class Perosn{String name; //这里定义了一个name属性返回值为默认的null
} 8.3 构造器 关于构造器一个类即使什么都不行都会存在一个方法这个方法是一个没有参数的方法
当我们创建对象时所使用的new关键字本质上是在调用我们的构造器。 需要注意的是我们可以定义有参数的构造器如果定义了他就需要再一次定义本身已经存在的无参构造器。
package com.oop.demo02;// java --- class
public class Person {// 一个类及时什么都不写它也会存在一个方法// 显示的定义构造器String name;// 实例化初始值//1. 使用new关键字本质是在调用构造器//2. 用来初始化值// 无参的构造器public Person(){this.name 周某;}// 有参构造一旦定义了有参构造无参就必须显示定义public Person(String name){this.name name;}
}
/*
在可执行的类中的代码
public class AppLication {public static void main(String[] args) {//new 实例化了一个对象Person person new Person(周鹭巡);System.out.println(person.name); // 周某}
}构造器1. 和类名相同2.没有返回值作用1. new 本质在调用构造方法2. 初始化对象的值注意点定义有参构造之后如果想使用无参构造显示定义一个无参的构造*/ 8.4 封装 关于封装就是在类里面定义属性的时候使用修饰符private在这个类里面可以定义一些可以操作这个属性的方法这些方法需要特定的名称。 get元素名 获得这个元素的值 set元素名 设置这个元素的值
package com.oop.demo04;public class Student {// 属性私有private String name;private int id;private String sex;private int age;// 提供一些可以操作这个属性的方法// 提供一些public的get、set方法// get 获得这个数据public String getName(){return this.name;}// set 给这个数据设置值public void setName(String name){this.name name;}public int getId(){return this.id;}public void setId(int id){this.id id;}public String getSex() {return sex;}public void setSex(String sex) {this.sex sex;}public int getAge() {return age;}public void setAge(int age) {if (age 120 age 0){this.age age;} else{this.age 20;}}
}/*
在可执行类中的代码public static void main(String[] args) {Student S1 new Student();S1.setName(周鹭巡);S1.setAge(999);S1.setId(35);S1.setSex(男);System.out.println(S1.getSex());System.out.println(S1.getId());System.out.println(S1.getName());System.out.println(S1.getAge());}封装1. 提高了程序的安全性保护数据2. 隐藏代码的实现细节3. 统一接口4. 系统可维护增加了*/ 8.5 继承、Super 继承就是直接在类名后面跟上关键词extends与父类的名字子类可以继承父类的所有方法。 Super就是在子类中调用父类中的属性或者父类中的方法。 直接在子类的构造器的代码第一行使用代码super();就是调用父类的构造器。 Person父类
package com.oop.demo05;// 在Java中所有的类都默认直接或者间接继承Object
// Person 人父类
public class Person /*extends Object*/ {public Person() {System.out.println(Person无参执行了);}private int money 10_0000_0000;public void say(){System.out.println(说什么呢);}public int getMoney() {return money;}public void setMoney(int money) {this.money money;}protected String name zhoumou;// 私有的东西无法被继承public void print(){System.out.println(Person);}
}Student子类
package com.oop.demo05;// 学生 is 人 派生类子类
// 子类继承了父类就会拥有父类的全部方法
public class Student extends Person {// Ctrl Hpublic Student() {// 隐藏代码调用了父类的无参构造super();//调用父类的构造器必须在子类构造器的第一行System.out.println(Student无参构造执行了);}public void print(){System.out.println(Student);}public void test1(){print();this.print();super.print();}private String name zlx;public void test(String name){System.out.println(name);System.out.println(this.name);System.out.println(super.name);}
}8.6 方法的重写 我是这么理解的当创建对象时类型为这个对象所属的父类时他所调用的父类引用的方法是指向的子类就好像儿子不听爸爸话了。 其实方法的重写就是调用方法是方法的修饰符静态与非静态的区别。 你给别人弄成了静态的话那么调用时遵循的就是创建对象时左边的数据类型了。 如果是非静态的话子类就不听父类话了就都是向子类的方法看齐你是调用到的父类的方法但是引用到的确实子类的方法。
可执行类
public class AppLication{public static void main(String[] args) {//静态的方法与非静态的方法区别很大// 方法的调用只和左边的数据类型有关A a new A();a.test();// 父类的引用指向了子类B b new A();b.test();}
}
A类
package com.oop.demo05;public class A extends B {Override // 注解有功能的注释public void test() {System.out.println(Atest());}
}B类
package com.oop.demo05;// 重写都是方法的重写与属性无关
public class B {public void test(){System.out.println(Btest());}
}执行后的结果就是
