-
1. 若在Eclipse中，类里创建了private属性，这里可以利用Eclipse快捷键自动创建get set方法. (点击Eclipse ， sources(源码) ,下面有一个setter...代表自动创建入口方法) 2.自动创建后，属性名往往与参数名相同，为了区分，就用到this关键字. this.screen代表当前对象的属性. this.方法名()则代表调用当前对象的方法.看视频
02:48
-
练习笔记：package exercise; public abstract class Shape{ public abstract double perimeter(); public abstract double area(); } public class Rectangle extends Shape{ private double length; private double width; public Rectangle(double length, double width){ this.length = length; this.width = width; } public double perimeter(){ return (length + width) * 2; } public double area(){ return length * width; } } public class Circle extends Shape{ private final double PI = 3.1415926; private double radius; public Circle(double radius){ this.radius = radius; } public double perimeter(){ return 2 * PI * radius; } public double area(){ return PI * radius * radius; } } public class Test { public static void main(String[] args) { Shape rec = new Rectangle(2, 3); Shape cir = new Circle(4); System.out.println(rec.perimeter() + " " + rec.area()); System.out.println(cir.perimeter() + " " + cir.area()); } } -
package yeyu; public class Trafic { public int loadPerson; public void function(){ System.out.println("交通工具具有载人的功能"); } } package yeyu; public class Bus extends Trafic { public void function(){ System.out.println("公共汽车在陆上载客："+loadPerson+"人"); } } package yeyu; public class Plane extends Trafic{ public String loadPerson; public void function(){ System.out.println("飞机在空中载客："+loadPerson+"人"); } } package yeyu; public class Board extends Trafic { public void function(){ System.out.println("轮船在海上载客："+loadPerson+"人"); } } package yeyu; public class TraficText { public static void main(String[] args) { // TODO Auto-generated method stub Trafic load1=new Bus(); Trafic load2=new Board(); Plane load3=new Plane(); load1.loadPerson=40; load2.loadPerson=200; load3.loadPerson="XXX"; load1.function(); load2.function(); load3.function(); } } -
静态内部类： 1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员 3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类(); -
new 一个对象是实例吗？ 对，是实例，你说的没错。可以把这个new出来的对象叫做实例，说白了就是这个new出来的“东西”，叫它对象也可以，叫它实例也可以，对象和实例在这个角度上来讲是等价的。 这样： Java中使用 new关键字 加上 构造方法，来创建一个对象，下面是一个名为Cat的类, public class Cat { public Cat() { System.out.println("这是构造方法"); } } 使用new + 构造方法 来创建一个对象，那么也就是 Cat c = new Cat(); 前半部分，Cat c 的意思是，在内存中分配一个变量，名字叫c，这个变量是Cat类型的，它的值是什么？ 一会儿在说； 后半部分，new Cat(); 这就是new关键字和构造方法来创建一个对象，Cat()是构造方法的名字没错吧？想造出一个对象来，就这么写，语法规定的，没有为什么； new Cat(); 说明 new这个Cat类的一个对象，程序运行的时候，会调用构造方法Cat()，等这个构造方法执行完了，这个Cat类型的对象也就造出来了，真正的出现在内存当中了； 使用new关键字造出来的对象，被分配在内存的堆区(heap)，而且等这个对象真正出来之后，还会做一件重要的事情： 我们这个对象是被分配在内存中的，那么内存地方大了，这个对象在哪里呢？怎么找到它呢？new关键字创建出一个对象之后，会把这个对象在内存中的地址返回，通过这个地址就可以找到这个对象，那么我们上面的写法, Cat c = new Cat(); 意思就是说，把这个对象在内存中的地址 赋值 给变量c，这就是Java中引用概念，c就叫做引用，或者叫引用变量，或者直接叫变量，没问题，都是它； c的值就是一个内存地址，或者叫引用地址，通过这个地址，就可以准确的找到我们刚才创建出来的对象，以后我们要使用这个对象做一些事情，调用此对象的方法什么的，都用过这个引用，ok？ ---- 注意，我再说一遍，好多人都搞不清楚，这个c到底是对象还是引用，好多人说c就是Cat类的一个实例，这是非常错误的，c就是引用，不是对象！我们new出来的这个东西，真正在内存中的这个东西叫做对象，叫做实例 个人理解：对象是内存中类的属性集合，变量是这个集合在内存中的引用地址看视频
00:57
-
面向对象的三大特性：封装、继承、多态 封装： 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现。 封装实现方法：1）、修改属性可见性。2）、创建getter\setter方法。3）、在getter\setter中加入属性控制语句(对属性值的合法性进行判断)。 封装 ： 1.类变成private float screen; 2. 加get/set public float getScreen(){ return screen; } public void setScreen(float newScreen){ screen=newScreen; } 3. main调用： phone.setscreen(6.0f); System.out.printly(phone.getScreen()); 好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现。看视频
01:53
-
父类
Car
<!--此处有图片-->
子类
PassengerCar
<!--此处有图片-->
Pickup
<!--此处有图片-->
Truck
<!--此处有图片-->
主程序
Tset
<!--此处有图片-->
<!--此处有图片-->
<!--此处有图片-->
-
super关键字的应用： 1.子类的构造过程中必须调用其父类的构造方法 2.如果子类的构造方法没有显示调用父类的构造方法，则系统会默认调用父类的无参构造方法。 3.如果显示的调用构造方法，必须在子类的构造方法的第一行，super()。 4.如果子类的构造方法中既没有显示调用父类的构造方法，父类又没有无参的构造方法，则编译就会报错 -
-
/** * @Author 王权 */ abstract class Car { String name;//名称 int rentPrice;//租金 int personCapacity;//载人量 int goodsCapacity;//载货量 } class LoadPersonCar extends Car{ public LoadPersonCar(String name, int rentPrice,int personCapacity) { this.name = name; this.rentPrice = rentPrice; this.personCapacity = personCapacity; } } class LoadGoodsCar extends Car{ public LoadGoodsCar(String name, int rentPrice,int goodsCapacity) { this.name = name; this.rentPrice = rentPrice; this.goodsCapacity = goodsCapacity; } } class LoadPersonAndGoodsCar extends Car{ public LoadPersonAndGoodsCar(String name, int rentPrice,int personCapacity,int goodsCapacity) { this.name = name; this.rentPrice = rentPrice; this.personCapacity = personCapacity; this.goodsCapacity = goodsCapacity; } } class AudiA4 extends LoadPersonCar{ public AudiA4(String name, int rentPrice,int goodsCapacity) { super(name, rentPrice,goodsCapacity); } } class MaZiDa6 extends LoadPersonCar { public MaZiDa6(String name, int rentPrice,int personCapacity) { super(name, rentPrice,personCapacity); } } class PiKaXue6 extends LoadPersonAndGoodsCar { public PiKaXue6(String name, int rentPrice,int personCapacity,int goodsCapacity) { super(name, rentPrice,personCapacity,goodsCapacity); } } class JinLong extends LoadPersonCar { public JinLong(String name, int rentPrice,int personCapacity) { super(name, rentPrice,personCapacity); } } class SongHuaJiang extends LoadGoodsCar { public SongHuaJiang(String name, int rentPrice,int goodsCapacity) { super(name, rentPrice,goodsCapacity); } } class YiWeiKe extends LoadGoodsCar { public YiWeiKe(String name, int rentPrice,int goodsCapacity) { super(name, rentPrice,goodsCapacity); } } import com.sun.org.apache.xpath.internal.SourceTree; import java.util.Scanner; /** * Created by Administrator on 2019/2/15 0015. */ public class DaDaRentCarSystem { public static void main(String[] args) { //初始化汽车种类 Car[] carArray = new Car[6]; carArray[0] = new AudiA4("奥迪A4",500,4); carArray[1] = new MaZiDa6("马自达6", 400, 4); carArray[2] = new PiKaXue6("皮卡雪6", 450, 4, 2); carArray[3] = new JinLong("金龙", 800, 20); carArray[4] = new SongHuaJiang("松花江", 400, 4); carArray[5] = new YiWeiKe("依维柯", 1000, 20); Scanner in = new Scanner(System.in); System.out.println("欢迎使用答答租车系统："); System.out.println("您是否要租车：1是 0否"); int isRentCar = in.nextInt(); float priceCount = 0.0f; int personCount = 0; float goodsCount = 0.0f; if (isRentCar == 1) { System.out.println("您可租车的类型及其价目表："); System.out.println("序号\t汽车名称\t租金\t容量\t"); for (int i = 0;i<carArray.length;i++) { Car car = carArray[i]; if (car instanceof LoadPersonCar) { System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载人：" + car.personCapacity +"人\t"); } else if (car instanceof LoadGoodsCar) { System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载货：" + car.goodsCapacity +"吨\t"); } else { System.out.println(i +".\t" +car.name+"\t"+car.rentPrice+"元/天\t" + "载人：" + car.personCapacity +"人 " +"载货：" + car.goodsCapacity +"吨\t"); } } System.out.println("请输入您要租汽车的数量："); int rentNum = in.nextInt(); Car[] rentCar = new Car[rentNum]; for (int i = 0;i<rentNum;i++) { System.out.println("请输入第" + i +"辆汽车的序号："); int seq = in.nextInt(); rentCar[i] = carArray[seq]; } System.out.println("请输入租车天数："); int day = in.nextInt(); for (Car car : rentCar) { if (car instanceof LoadPersonCar) { personCount += car.personCapacity; priceCount += car.rentPrice * day; } else if (car instanceof LoadGoodsCar) { goodsCount += car.goodsCapacity; priceCount += car.rentPrice * day; } else { personCount += car.personCapacity; goodsCount += car.goodsCapacity; priceCount += car.rentPrice * day; } } System.out.println("您的账单："); System.out.println("***可载人的车有："); for (int i = 0;i<rentCar.length;i++) { if (rentCar[i] instanceof LoadPersonCar || rentCar[i] instanceof LoadPersonAndGoodsCar) { System.out.print(rentCar[i].name +" "); } } System.out.println("共载人：" + personCount + "人" ); System.out.println("***可载货的车有："); for (int i = 0;i<rentCar.length;i++) { if (rentCar[i] instanceof LoadGoodsCar || rentCar[i] instanceof LoadPersonAndGoodsCar) { System.out.print(rentCar[i].name + " "); } } System.out.println("共载货：" + goodsCount + "吨" ); System.out.println("租车总价格：" +priceCount+"元" ); } } } -
-
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 好处：1、只能通过规定的方法访问数据。 2、隐藏类的实例细节，方便修改和实现 封装的步骤：1、修改属性的可见性，设为private 2、创建个getter/setter方法用于属性的读写 3、在getter/setter方法中加入属性控制语句，对属性值的合法性进行判断 众所周知，JAVA是面向对象的一门语言，每个对象都有各自的属性和方法．但是有的属性涉及安全因素或秘密因素不能让外面的程序调用，所以就用到了private, 经过它定义的变量只能在此对象内部调用，外部程序就无法调用，也就是说只能供其自身调用，比如某个人是一个对象，那么他的血液就肯定是私有变量，只能供其自身调用来维持人的状态．而如果将血液定义成public(公共的)的话，随便其他人都可以改变他血液的状态，你随便把他的血液值设为逆流，那他不就挂了． -
equals（）默认是Object的方法。比较的是两个对象的内存地址，即使是两个对象的值完全是一样的，他们这是存在两个完全不同的空间，这里指的是内存空间。 如果重新equals方法的话，会显示以下的代码： public boolean equals(Object obj){ /*修饰符为公开，数据类型是判断真假值得布尔代数，方法名是equals，（Object obj）这个参值是Object类中的对象值，用来检测JAVA中对象用的*/ if(this == obj)/*判断对象是一个对象,返回值是真*/ return ture; if(obj == null)/*判断这个对象什么都没有，返回值是假*/ return false; if(getClass() != obj.getClass())/*判断对象属性和对象属性的值不符合，返回值是假*/ return false; 类A other = (类A)obj;/*上述已经足够判断参值对象基本属性是否为一个类型，这里讲参值对象执行为一个类型*/ if(变量名 != other.变量名)/*这里判断两个对象的某个变量中的值不相等，返回值是假*/ return false; …………/*继续执行对比其他变量中的变量值是否不相等*/ return true;/*返回值是真，判断两个对象为相等继而通过，否则就不相等*/ -
从对象的内存角度来理解. 假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,里面的变量需要占用0.5M内存. 现在通过代码来看看内存的分配情况: 2.f = new Father();//系统将分配1M内存. Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.由于s中包含了父类的实例,所以s可以调用父类的方法. 3.Son s1 = s;//s1指向那1.5M的内存. Father f1 = (Father)s;//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中). Son s2 = (Son)f;//这句代码运行时会报ClassCastException.因为f中只有1M内存,而子类的引用都必须要有1.5M的内存,所以无法转换. Son s3 = (Son)f1;//这句可以通过运行,这时s3指向那1.5M的内存.由于f1是由s转换过来的,所以它是有1.5M的内存的,只是它指向的只有1M内存. -
1.方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。 2.方法内部类使用时，在方法中创建内部类对象，用对象调用其内部类中的方法。 注：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
02:48
00:57
01:53
举报
0/150
提交
取消