1.1面向过程：是一种编程思想，强调的是过程，凡事亲力亲为。
1.2面向对象：是一种编程思想，强调的是结果。
2.面向对象的三大特征：
1）封装
2）继承
3）多态
3.类和对象
类：是抽象的，类似于类型，我么你可以将其理解为一类事物的模板
对象：是具体的，是根据类具体创造出来的事物
4.面向对象入门案例
package cn.tedu.oop;
/*本类用于面向对象入门案例
* 在一个Java文件中可以写多个class，但是被public修饰的只能有一个
* 而且这个公共类的名字要求就是当前文件的名字*/
public class TestGreateClass {
public static void main(String[] args) {
//4.通过new关键字创建对应类的对象
Phone p = new Phone();
//5.通过创建好的对象使用类中的功能
p.call();
p.message();
p.video();
//6.通过创建好的对象查看属性值
System.out.println(p.brand);
System.out.println(p.price);
System.out.println(p.color);
System.out.println(p.size);
//7.创建手机类的第二个对象
Phone p2 = new Phone();
System.out.println(p2);
//8.通过p2对象调用Phone类的三个功能
p2.video();
p2.message();
p2.call();
//9.给p2对象的属性赋值并查看
p2.brand = "华为";
p2.price = 8888.88;
p2.size = 5.6;
p2.color = "宝石蓝";
System.out.println("手机品牌是："+p2.brand);
System.out.println("手机颜色是："+p2.color);
System.out.println("手机价格是："+p2.price+"元");
System.out.println("手机大小是"+p2.size+"寸");
}
}
//1.通过class关键字创建手机类--用来描述手机这一类事物
//类是一类事物的抽象，用来描述这一类事物的特征与行为
class Phone{
//特征（属性）--类的成员变量来描述--定义在类方法外的变量
String brand;
//品牌
double price;
//价格
double size;
//尺寸
String color;
//颜色//3.定义手机的功能--类的方法来描述--修饰符 返回值类型 方法名（参数列表）{方法体}
public void call(){
System.out.println("正在打电话~");
}
public void message(){
System.out.println("正在发短信~");
}
public void video(){
System.out.println("正在看片~");
}
}
package cn.tedu.oop;
//本类用于面向对象巩固
public class TestCat {
public static void main(String[] args) {
Cat m = new Cat();
m.jump();
m.miaoMiao();
System.out.println(m);
//6.创建小猫的对象2
Cat m2 = new Cat();
m2.jump();
m2.miaoMiao();
m.name = "黑炭";
m.age = 3;
m.hosts = "静静";
m2.name = "煤球";
m2.age = 2;
m2.hosts = "爱丽丝";
System.out.println("小猫的名字是："+m.name);
System.out.println("小猫"+m.age+"岁啦~");
System.out.println("小猫的主人是："+m.hosts);
System.out.println("小猫的名字是："+m2.name);
System.out.println("小猫"+m2.age+"岁啦~");
System.out.println("小猫的主人是："+m2.hosts);
}
}//1.通过class关键描述小猫这一类事物
class Cat{
//2.属性
String name;
int age;
String hosts;
//3.功能
public void jump(){
System.out.println("小猫跳的老高了");
}
public void miaoMiao(){
System.out.println("小猫喵喵叫~~~~");
}
}
5.面向对象的第一大特性--封装 封装属性的思路：1.用private修饰资源
2.提供公共的get方法，用来获取值
3.提供巩固的set方法，用来设置值
封装方法的思路：1.用private修饰资源
2.用本类的公共方法调用这个被封装方法的功能
package cn.tedu.oop;
/*本类用于继续测试面向对象的第一大特性--封装*/
public class TestPrivate2 {
public static void main(String[] args) {
//4.创建学生类对象
Student s = new Student();
//5.通过对象操作学生类的属性与方法
System.out.println(s.name);
s.study();
//6.1通过对象修改属性的值，并打印查看
//s.subject = "java培优";
//System.out.println(s.subject);
s.name = "陈平安";
System.out.println(s.name);
//s.sno = 20210929;
//System.out.println(s.sno);
//6.4 调用自动生成的set与get方法
s.setSubject("CGB");
System.out.println(s.getSubject());
//7.3调用get与set方法操作被封装的属性
s.setSno(21090929);
int r = s.getSno();
System.out.println(s.getSno());
}
}//1.使用class关键字描述学生这一类型
class Student{
//2.学生属性：学号，姓名，科目
//7.1使用private关键字封装属性
private int sno;
public int getSno() {
return sno;
}public void setSno(int sno) {
this.sno = sno;
}String name;
//6.2使用private修饰subject属性
private String subject;
//右键-Generate-getter and setter-再点那个锁-点ok
//7.2添加被封装属性的get和set方法public String getSubject() {
return subject;
}public void setSubject(String subject) {
this.subject = subject;
}//3.学生功能：学习，吃饭，睡觉
public void study(){
System.out.println("别吵，学习呢~");
}
public void eat(){
System.out.println("干饭不积极，思想有问题~");
}
public void sleep(){
System.out.println("我一点也不想睡觉，我想学Java");
}
}封装的必要性
package cn.tedu.oop;
//本类用于测试封装的必要性
public class TeatPrivate1 {
public static void main(String[] args) {
//3.创建对象修改属性值
User u = new User();
u.name = "葫芦娃";
System.out.println(u.name);
//u.money = 1000000;
//System.out.println(u.money);
//6.调用查看余额的方法
System.out.println(u.getMoney());
//7.调用设置余额的方法，设置余额为999999
u.setMoney(999999);
//设置完，通过获取money的方法再次查看余额值
System.out.println(u.getMoney());
}
}//1.创建一个用户类
class User{
//2.定义用户类的属性
public String name;
//姓名
//4.为了更安全的操作余额，修改money的修饰符为private
/*被private修饰的资源只能在本类中使用*/
private double money=10000;
//账户余额
//5.1提供公共的方法共外界调用，方法的功能：获取余额
public double getMoney(){
/*如果方法的返回值不是void
* 就需要适应return关键字返回对应类型的返回值*/
/*后续可以增加权限的验证*/
return money;
}
//5.2提供公共的方法共外界调用，方法的功能：修改余额
public voidsetMoney(double newMoney){
/*后续可以添加权限的效验*/
money = newMoney;
//将调用方法时传入的值newMoney设置给成员变量money
}
}
面向对象巩固练习
package cn.tedu.oop;
/*本类用于面向对象的巩固练习*/
public class TestCar {
public static void main(String[] args) {
//4.在公共类当中创建汽车类对象
Car c = new Car();
//5.设置创建好的对象的属性值
//c.brand = "BWM";
//c.color = "黑色";
//c.price = 300000;
//c.length = 3.2;
//6.查看设置好的属性
//System.out.println(c.brand);
//System.out.println(c.color);
//System.out.println(c.price);
//System.out.println(c.length);
//7.3操作set方法给所有属性赋值
c.setBrand("布加迪威龙");
c.setColor("暗夜黑");
c.setPrice(40000000);
c.setLength(3.3);
//7.4操作get方法查看属性的赋值是否成功
System.out.println(c.getBrand());
System.out.println(c.getColor());
System.out.println(c.getPrice());
System.out.println(c.getLength());
//8.通过创建好的对象调用汽车类的功能
c.start();
//c.stop();
}
}
//1.抽象汽车这一类事物的共同点，用class描述
class Car{
//2.属性--用成员变量来描述
//7.1封装所有属性
private String brand;
//品牌
private String color;
//颜色
private double price;
//价格
private double length;
//车长//3.功能--用方法来描述
public void start(){
System.out.println("汽车启动了~");
//9.2在本类的公共方法里调用被封装的方法
stop();
}
//9.1用private封装汽车停止的方法
private void stop(){
System.out.println("汽车停止了~");
}
//7.2生成所有属性对应的get和set方法public String getBrand() {
return brand;
}public void setBrand(String brand) {
this.brand = brand;
}public String getColor() {
return color;
}public void setColor(String color) {
this.color = color;
}public double getPrice() {
return price;
}public void setPrice(double price) {
this.price = price;
}public double getLength() {
return length;
}public void setLength(double length) {
this.length = length;
}
}
6.构造函数
格式：与本类名同名，且没有返回值
作用：创建对象，创建一次，执行一次构造函数
分类：
1.无参构造：默认存在，如果添加了其他构造，默认的构造函数会被覆盖
2.含参构造：对于参数没有任何要求，有参数就行。
3.全参构造：全参构造的参数必须与本类属性一致
全参构造不仅可以创建对象，还可以给对象的所有属性赋值
可以使用idea在类的属性下使用
鼠标右键-Generate-Constructor-Shift全选所有属性-ok来创建
package cn.tedu.oop;
/*本类用作构造函数的入门案例*/
public class TestConstructor {
public static void main(String[] args) {
//4.创建Person类的对象
/*1.每次new 对象时都会自动触发对应类中的构造方法
* 2.每一个类中都会默认存在一个没有参数的构造方法
* 但是，如果你提供了其他的构造函数，默认的无参构造会被覆盖
* 所以，我们要手动的提供无参构造，这样才能不传参数，也能创建对象*/
Person p1 = new Person();
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.address);
p1.eat();
/*4.每次创建对象都会执行一个构造方法
* 构造方法的作用：用来创建对象的*/
Person p2 = new Person(555);
System.out.println(p2.name);
/*5.全参构造不仅可以创建对象，还可以给对象的所有属性赋值*/
Person p3 = new Person("张三",18,"浙江");
System.out.println(p3.name);
System.out.println(p3.age);
System.out.println(p3.address);
}
}
//1.创建Person类，描述人这一类事物
class Person{
//2.定义属性
String name;
//姓名
int age;
//年龄
String address;
//地址
/*3.构造方法的格式：与本来类名同名，且没有返回值类型的方法*/
//5.1创建本类的无参构造
public Person(){
System.out.println("我是Person类的无参构造");
}
//5.2创建本类的含参构造--含有参数的构造方法
public Person(int n){
System.out.println("我是Person类的含参构造"+n);
}
//5.3创建本类的全参构造--此构造函数的参数与本类的属性一致
//右键-Generate-Constructor-Shift全选所有属性-ok
public Person(String name, int age, String address) {
System.out.println("我是Person类的全参构造");
this.name = name;
this.age = age;
this.address = address;
}
//3.功能--方法
public void eat(){
System.out.println("端起了我的饭盆~");
}
}
7.代码块
1.构造代码块：
①.位置：类里，方法外
②.执行时机：每次创建对象时执行，并且优先于构造方法执行
③.作用：用于提取所有构造方法的共同功能
2.局部代码块：
①.位置：方法里
②.执行时机：调用本局部代码块所处的方法时执行
③.作用：用于控制变量的作用范围
package cn.tedu.oop;
/*本类用于测试代码块
* 执行顺序： 构造代码块>构造方法> 普通方法>局部代码块
* 1.当创建对象时，会触发构造函数
* 2.创建对象时，也会触发构造代码块，并且构造代码块优先于构造方法执行
* 3.我们创建好对象后才能通过对象调用普通方法
* 4.如果普通方法里有局部代码块，才会触发对应的局部代码块*/
public class TestBlock {
public static void main(String[] args) {
Pig p1 = new Pig();
Pig p2 = new Pig("佩奇");
Pig p3 = new Pig("肉包子",5);
System.out.println(p1.age);
//0，默认值
System.out.println(p2.age);
//0默认值
System.out.println(p3.age);
//5，创建对象时赋值
p1.eat();
p2.eat();
p2.eat();
}
}
class Pig{
String food;
int age;
{
/*构造代码块：{}
* 1.位置：类里，方法外
* 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
* 3.作用：用于提取所有构造方法的共性功能*/
System.out.println("我是一个构造代码块");
System.out.println("黑猪肉");
}
public void eat(){
System.out.println("小猪爱吃菜叶子");
{
/*
* 局部代码块：{}
1.位置：在方法里
2.执行时机：调用本局部代码块所处的方法时才会执行，并且构造方法优先于局部代码块执行
3.作用：用于控制变量的作用范围，变量的作用范围越小越好
*/
System.out.println("我是一个局部代码块");
int i = 100;
System.out.println(i);
}
//System.out.println(i);
//局部代码块中的局部变量i只能在代码块里使用
}
public Pig(){
System.out.println("我是Pig类的无参构造~");
}
public Pig(String s){
System.out.println("我是Pig类的有参构造"+s);
}
public Pig(String food,int age){
System.out.println("我是Pig类的全参构造");
this.food = food;
this.age = age;
}
}
8.继承extends
package cn.tedu.opp2;
/*本类用于继承的入门案例*/
public class TestExtents {
public static void main(String[] args) {
//5.分别创建3个类的对象
Animal a = new Animal();
Cat c = new Cat();
MiaoMiao m = new MiaoMiao();
//6.利用对象调用方法进行测试
/*3.继承相当于是子类将父类的功能复制了一份
继承还具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子
*/
a.eat();
//爷爷类使用自己的方法
c.eat();
//爸爸类可以使用从爷爷类中继承过来的方法
m.eat();
//孙子类也可以使用从爷爷类中继承过来的方法
}
}
/*1.我们通过extends关键字建立子类与父类的继承关系，格式：子类 extends 父类
* 2.Java只支持单继承，一个子类只能有一个父类，但是一个父类可以有多个子类*/
//1.创建小动物类--爷爷类
class Animal{
//4.添加爷爷类的普通方法
public void eat(){
System.out.println("小动物Animal吃啥都行~");
}
}
//2.创建小猫类--父类
/*6.继承是is a 的关系，比如小猫是小动物，MiaoMiao是一只小猫
* 继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合*/
class Cat extends Animal{
//7.定义爸爸类中的属性
int a = 10;
//普通属性
private int b = 100;
//私有属性
}
//3.创建MiaoMiao类--孙子类
class MiaoMiao extends Cat{
/*4.子类可以拥有自己独有的方法，实现了功能的拓展，青出于蓝而胜于蓝*/
//8.定义孙子类的方法
public void studyJava(){
System.out.println("正在学java");
System.out.println(a);
/*5.子类继承了父类以后，可以使用父类的所有非私有资源
* 注意：这个私有资源由于被private修饰，所以没有访问权限*/
//System.out.println(b);
//不可以，私有资源被限制访问
}
}
①this的用法
1.当成员变量与局部变量同名时，使用this指定成员变量
2.使用this在构造方法的第一行调用构造方法的功能
this(); --调用的是本类的无参构造
this(参数); --调用的是父类对应参数的构造方法
package cn.tedu.oop;
/*本类用于this测试*/
public class TestThis1 {
public static void main(String[] args) {
//4.创建对象并调用方法
Cat c = new Cat();
c.eat();
}
}
//1.创建小猫类
class Cat{
//5.创建成员变量
int count = 666;
int sum = 100;
//2.创建方法
public void eat(){
//3.创建局部变量
int sum = 10;
System.out.println(sum);
//10使用的是局部变量，就近原则
/*当成员变量与局部变量同名时，可以使用this指定本类的成员变量
如果不使用this指定，打印的就是近处的这个局部变量，就近原则*/
System.out.println(this.sum);
//100
System.out.println(count);
}
}
package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
public static void main(String[] args) {
//3.1触发无参构造创建本类对象
Dog d1 = new Dog();
//3.2触发有参构造创建本类对象
Dog d2 = new Dog("旺财");
}
}
//1.创建小狗类
class Dog{
//2.1创建本类无参构造
public Dog(){
/*在无参构造中调用含参构造的功能
* 注意：调用是单向的，不能来回双向调用，否则会死循环*/
this("小汪汪~");
System.out.println("我是一个无参构造");
}
//2.2创建本类含参构造String s
public Dog(String s){
/*在含参构造中，调用无参构造的功能
* 规定：this关键字必须在构造函数的第一行*/
//this();
System.out.println("我是一个含参构造"+s);
}
}
②super的用法
1.当父类的成员变量与子类的变量同名时，使用super指定父类的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super(); --调用的是父类的无参构造
super(参数); --调用的是父类对应参数的构造方法
package cn.tedu.opp2;
/*本类用于测试继承中变量的使用*/
public class TestExtendsDemo1 {
public static void main(String[] args) {
//7.创建子类的匿名对象，调用study
new Son().study();
}
}
//1.创建父类
class Father{
//3.创建父类的成员变量
int sum = 1;
int count = 2;
}
//2.创建子类
class Son extends Father{
//4.创建子类的成员变量
int sum = 10;
//5.创建子类的普通方法
public void study(){
System.out.println("good good study,day day up!");
//6.创建子类的局部变量
int sum = 100;
//8.打印子类的局部变量sum
System.out.println(sum);
//100
//9.打印子类的成员变量sum
System.out.println(this.sum);
//10
//10.打印父类的成员变量sum
/*当父类的成员变量与子类的成员变量同名时，可以使类用super指定父的成员变量
我们可以把super看作是父类的对象：Father super = new Father();
*/
System.out.println(super.sum);
//1
}
}
package cn.tedu.opp2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时，默认会先调用父类的构造方法
* 2.原因是子类构造函数中的第一行默认存在super();
--表示调用父类的无参构造
* 3.当父类的无参构造被覆盖时，可以通过super(参数)调用父类的其他含参构造
* 子类必须调用父类的构造函数，不管是无参还是含参，选一个即可
* 4.构造方法不可以被继承！因为语法的原因：要求构造方法的类名必须是本类类名，
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
public static void main(String[] args) {
//6.1通过父类的无参构造创建父类对象
//Father2 f = new Father2();
//6.通过父类的含参构造创建父类对象
//Father2 f2 = new Father2("哈哈哈");
//7.创建子类对象
Son2 s = new Son2();
}
}
//1.创建父类
class Father2{
//3.创建父类的无参构造
//public Father2(){
//System.out.println("我是父类的无参构造");
//}
//4.创建父类的含参构造
public Father2(String s){
System.out.println("我是父类的含参构造"+s);
}
}
//2.创建子类
class Son2 extends Father2{
//5.创建子类的无参构造
public Son2(){
//super();
//调用父类的无参构造
super("您好~");
System.out.println("我是子类的无参构造");
}
}
【java|Java面向对象，封装，继承的基础练习】
推荐阅读
- java|达内cgb2111第一次月考 76分
- 达内培训期间所学的知识|CGB2111开班第六天
- 学习经历|cgb2107-第三阶段-day03-Mybatis入门
- 达内培训期间所学的知识|CGB2111开班第七天
- 第一阶段|【第一阶段 day22 面向对象】面向过程 面向对象 类 对象 类与对象的关系 对象创建过程分析 封装 访问控制符
- spring|手把手带你搭建SpringCloud， 从公共模块搭建一套完整微服务架构
- 程序员|全靠这套面试题，Java高级工程师每日面试题精选
- 程序员|Java高级工程师每日面试题精选，一文全懂
- Java|吊打级的福利，BAT上班是种什么样的体验 ?