1.类和对象的关系
类是抽象的,对象是具体的,类是具有相同属性和方法的对象的集合,对象是类的一个实例,是一个具体的实体
创建类和对象
创建一个类(属性和方法)
通过这个类创建对象 (构造方法)
使用对象名调用属性和方法, 对象名.属性; 对象名.方法名();
方法的定义
方法定义类的某种行为或功能,是功能的实现
2.方法的五要素
(1)访问权限修饰符
public protected 默认修饰符 private
这几个修饰符的区别:
public修饰的内容在任何地方都可以访问;private修饰的内容只有本类可以访问;默认修饰符修饰的内容可以在同一个包下访问;protected修饰的内容可以在同一个包下访问,并且所有的子类也可以访问(不管是不是同包)
(2)返回值类型:
如果方法有返回值,方法中必须使用关键字return返回某个值,返回值类型为该值的类型,且返回值只能有一个
return作用:结束方法,返回结果
注意:当调用有返回值的方法时,需要定义一个变量接收.如果方法没有返回值, 返回值类型为void;构造方法没有返回值类型
(3)方法名:
方法名的定义遵循驼峰原则:首字母小写,而后每个单词首字母大写
(4)参数列表
方法执行时的条件,没有内容则不需要条件
编写参数的语法和属性一致,数据类型 参数名
方法声明时的参数列表内是形式参数,也称为形参,就是一个占位符,不是具体值.当用户调用此方法时,需要传递符合形参的实际参数,也称为实参.如果定义的方法有多个形参,之间用逗号隔开
(5)方法体
{}中的内容,是此方法具体功能的实现
3.方法的调用
调用类的普通方法,需要创建该类的对象,对象名.方法名();
方法间可以相互调用,不需要知道方法的具体实现
4.构造方法 --创建对象,初始化对象
特点:
(1)修饰符必须是public
(2)没有返回值类型
(3)方法名必须和类名一致
(4)只有创建对象时才会调用,不能用类名.方法名()的方式调用,但是可以用this()的形式在其他构造方法中调用它,此时this()必须在代码块第一行
(5)类中没有显示的构造方法,系统会给出默认的无参构造方法,当类中有了有参构造方法,系统不会自动生成默认无参构造方法,若需要则重新定义即可
构造方法与普通方法的区别:
(1)构造方法的修饰符是public,一般方法根据实际情况选择
(2)构造方法没有返回值类型,一般方法要么是void要么有具体返回值类型
(3)构造方法名和类名相同,普通方法名见名思意,遵循驼峰原则
(4)构造方法体是对象的初始化代码,普通方法是功能的实现
(5)构造方法用new this super调用;普通方法使用对象调用
5.方法重载:overload
方法重载的判断标准:同类同名不同参(参数列表:个数不同,类型不同,类型顺序不同)
6.this关键字用法
调用属性:this.health = 100;
调用方法:this.print();
调用构造方法:this();this("小黑",100,90);这种方法调用必须位于构造方法第一行
7.成员变量与局部变量的区别
(1)定义位置不同:
成员变量属于类(其实就是属性)
局部变量属于方法
(2)作用域不同:
类中的每个方法都可以使用成员变量
局部变量只能在声明它的方法中使用
(3)初始值不同:
成员变量有默认初始值,在加载类的时候就会给成员变量赋值(默认值);局部变量没有初始值,必须初始化之后才可以使用
(4)生命周期不同:
成员变量随着对象的创建而创建,随着对象的消失而消失
局部变量随着方法的调用而创建
(5)优先级不同:
当局部变量和成员变量同名时,优先使用局部变量的值
8.封装
概念:java三大特性之一,将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
实现封装的步骤:
(1)私有化属性,使用private修饰
(2)创建公共的gettersetter方法
(3)在setter方法中添加控制语句
封装的好处:
(1)隐藏了实现的细节,提高安全性
(2)符合java的"高内聚,低耦合"思想
(3)提高软件的独立性和可重用性
9.包
作用:文档分门别类,易于查找和管理;
解决文件同名冲突的问题;
有助于实施访问权限管理;
package需要放在java源码的第一条语句,有且只有一条;
包名有小写字母组成,不能以圆点开头或结尾
包名之前最好加上唯一前缀,通常是组织倒置的域名
如果需要使用其他包下面的类,可以使用import关键字导入
import 包名.类名;放在package下面,可以有多条导入语句
10.static修饰符
可以用来修饰属性,修饰方法,修饰代码块
静态变量,静态方法,静态代码块
静态资源不需要依赖于对象,可以直接通过类名.静态资源
静态资源在内存中只有一个,不同的对象操作的都是同一个内容
注意:在类加载的时候,先加载静态资源,再加载非静态资源
每创建一个对象都会执行一次构造方法,但是静态代码块只会在第一次创建对象前执行一次
静态变量特点:
被static修饰;在内存中只有一个,加载类的时候创建,被所有方法和对象共享;其他类中直接通过类名访问
静态方法特点:
静态方法不能使用this和super;
不能直接访问所属类的实例变量和实例方法;
(面试题:静态方法能不能访问非静态资源?通过对象来访问;静态方法能不能直接访问非静态资源?不可以)
可以通过类名.方法名()访问;
规定:静态只能调用静态,非静态只能调用非静态;
11.静态变量和实例变量的区别:
静态变量:
被static修饰;在内存中只有一个拷贝;类内部可在任何方法内直接访问静态变量;其他类中使用类名.静态资源来访问;在创建对象之前会被加载;
实例变量:
没有被static修饰;每创建一个实例都会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响;必须要通过对象调用;随着对象的创建而被创建;
注意:在静态资源内部不能直接调用非静态资源(属性和方法)
规定:静态调用静态,非静态调用非静态
12.继承
java中继承使用extends关键字
类:具有共同属性和行为的一组对象,它是创建对象的模板或蓝图
子类:子类是继承其他类的类,它也称为派生类,扩展类或子类
超类/父类:超类是子类继承功能的类,也称为基类或父类,通用的方法和属性;
可重用性;
Java中类只支持单继承,一个类只能有一个直接父类,但是父类可以是其他类的子类
子类中如何调用父类的方法?
可以使用super关键字对弗雷德方法进行调用,super.方法名/属性;
super的用法有哪些?
调用父类的方法/属性;调用父类的构造方法,必须位于第一行;子类在创建对象,调用自己的构造方法时,会先调用父类的构造方法
子类到底继承了父类的哪些内容?
公共的属性和方法;
被protected修饰的属性和方法;
当父类和子类在同一个包下的话,子类还继承了父类的默认修饰符修饰的内容
子类不能继承父类的内容:
private修饰的内容;
子类和父类不在同一个包下时,不能继承默认访问权限的成员;
不能继承父类的构造方法
继承什么时候使用?
符合is-a 关系的设计时,可以考虑使用继承
如:小狗是一个宠物,小猫是一个宠物,则可以设计宠物类作为小狗/小猫的父类
package com.sky.oop01;
public class GenshinRole {
String roleName;//角色名
int roleAge;//年龄
String roleProperty;//属性
String country;//所属国家
int atk;//攻击力
int bloodVolume;//血量
public GenshinRole(String _roleName,int _roleAge,String _roleProperty,String _country,int _atk,int _bloodVolume){
this.roleName = _roleName;
this.roleAge = _roleAge;
this.roleProperty = _roleProperty;
this.country = _country;
this.atk = _atk;
this.bloodVolume = _bloodVolume;
}
public void introduceOneself(){
System.out.println("我是"+roleName+","+roleAge+"岁了,来自于"+country+","+roleProperty+"属性"+",我一击伤害是"+atk+",我血量是"+bloodVolume);
}
public void successAttakZhongli(int _atk){
if(_atk >= 50000){
System.out.println("我能一击破钟离盾");
}else{
System.out.println("我不能一击破钟离盾");
}
}
public void chenshouLeishenyidao(int _bloodVolume){
if(_bloodVolume > 1000000){
System.out.println("我能正面接雷神一刀");
}else{
System.out.println("我不能正面接雷神一刀");
}
}
}
package com.sky.oop01;
public class Students {
/*
* 创建类
* 通过类创建对象
* 使用对象调用属性或者方法
*
*/
//属性
//数据类型 属性名;
int studentNo;//学号
String name;//名字
int age;//年龄
String stuClass;//班级
String hobby;//爱好
}
package com.sky.oop01;
public class Teachers {
String name;
String majorField;//专业方向
String course;//教授课程
int teachingYear;//教龄
}
package com.sky.oop01;
import java.util.Scanner;
public class Users {
String userName;
int pwd;
public void updatePassword(Users p){
//接收用户的输入,对比用户名密码,若正确则可以修改密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String _username = sc.next();
System.out.println("请输入密码:");
int _pwd = sc.nextInt();
boolean flag = true;
//判断字符串是否=相同用equals方法
if(p.userName.equals(_username)){
if(p.pwd == _pwd){
System.out.println("请输入新密码");
p.pwd = sc.nextInt();
flag = false;
}else{
System.out.println("用户名或密码不匹配,您没有权限更新管理员信息");
}
}else{
System.out.println("用户名或密码不匹配,您没有权限更新管理员信息");
}
if(!flag){
System.out.println("您的账户信息更新为"+p.userName+"\t"+p.pwd);
}
}
}
package com.sky.oop01;
public class Demo {
public static void main(String[] args) {
//根据类创建对象
//类名 对象名 = new 类名();
Students zhangsan = new Students();
zhangsan.name = "张三";
zhangsan.age = 12;
zhangsan.stuClass = "3年2班";
zhangsan.hobby = "篮球";
zhangsan.studentNo = 25;
System.out.println(zhangsan.name);
System.out.println(zhangsan.age);
System.out.println(zhangsan.stuClass);
System.out.println(zhangsan.hobby);
System.out.println(zhangsan.studentNo);
Teachers Lisi = new Teachers();
Lisi.name = "李四";
Lisi.majorField = "计算机";
Lisi.course = "Java大数据开发";
Lisi.teachingYear = 5;
System.out.println(Lisi.name);
System.out.println(Lisi.majorField);
System.out.println(Lisi.course);
System.out.println(Lisi.teachingYear);
//使用对象
//对象名.属性 对象名.方法名
//通过对象名属性进行赋值,同时可以适用对象名调用里面的方法
//属性是什么类型,就必须要赋什么类型的值
GenshinRole Hutao = new GenshinRole("胡桃",15,"火","璃月",60000,32000);
Hutao.introduceOneself();
Hutao.successAttakZhongli(Hutao.atk);
Hutao.chenshouLeishenyidao(Hutao.bloodVolume);
//创建对象p1并为其赋值
Users p1 = new Users();
p1.userName = "admin1";
p1.pwd = 111111;
p1.updatePassword(p1);
}
}
package com.sky.oop01;
public class Sightseer {
//属性
public String name;
public int age;
public int price;
//构造方法重载
public Sightseer(String _name,int _age,int _price){
this.name = _name;
this.age = _age;
this.price = _price;
}
public Sightseer(String _name,int _age){
this.name = _name;
this.age = _age;
}
//选择价格
public int selectPrice(int age){
if(age<18||age>=60){
this.price = 10;
}else if(age<60&&age>=18){
this.price = 20;
}
else{
System.out.println("年龄输入错误 ");
return -1;
}
return price;
}
//打印
public void printPrice(){
System.out.println(this.name+"的年龄为:"+this.age+",门票价格为:"+this.selectPrice(this.age)+"元");
}
}
package com.sky.oop01;
import java.util.ArrayList;
import java.util.Scanner;
public class SightseerTest {
public static void main(String[] args) {
//循环创建一个游客对象,输出应该多少票价
Scanner sc = new Scanner(System.in);
while(true){
System.out.print("请输入姓名:");
String _name = sc.next();
if(_name.equals("n")){
System.out.println("程序结束");
break;
}
System.out.print("请输入年龄:");
int _age = sc.nextInt();
Sightseer person = new Sightseer(_name,_age);
person.printPrice();
}
}
}
package com.sky.oop2;
import java.util.Arrays;
public class Student {
//类型 属性名;
int studentNo;
String name;
int age;
String address;
//构造方法--作用,创建和初始化对象
/*
* 修饰符必须是public ,没有返回值类型,方法名必须和类名保持一致
*
* 注意:
* 1.构造方法在创建对象的时候执行,不能像普通方法一样被调用
* 2.如果类当中没有显示的构造方法的话,系统会帮你创建一个无参的构造方法
* 只要类中出现了构造方法,系统则不会帮你创建构造方法
* 3.关键字:this,当前对象,谁来调用这个方法,this指的就是谁
*/
public Student(){
}
//方法
//当前类的属性在当前类的方法中是可以直接使用的
public void show(){
System.out.println("我叫:"+name+",今年:"+age+",家住:"+address);
}
/*方法:功能
* 方法的五要素:
* 访问权限修饰符(public,pravite,protect)
* 返回值类型 void
* 方法名 eat
* 参数列表 ()方法执行时要不要条件,没有内容则不要条件,编写参数的语法与属性一致 ,数据类型 参数名(形式参数),调用时需要传递实参
* 形参的值是由调用者在传递时决定的
* 方法体 {}具体功能的实现步骤
*/
public void eat(){
System.out.println("我喜欢吃老乡鸡");
}
public String buySmoke(int money){
String yanming = "";
System.out.println("我骑车去买烟,老师给了:"+money+"元");
if(money<=10&&money>0){
yanming = "红塔山";
}else if(money <=30){
yanming = "玉溪";
}else if(money>30){
yanming = "中华";
}else{
System.out.println("金钱错误");
}
return yanming;
}
/*
* 向指定数组中,增加学员姓名,成功之后返回true
* 可以再数组中查看所有学生姓名
*/
public String[] add(String name,String[] names){
/*
* 1.判断数组是否满了
* 1.1获取数组的最后一位,如果有值,说明数组满了,对数组进行扩容,将值存在最后一个位置;如果没有值,
* 说明数组还有空位,找到第一个为空的下标,将name存储到该位置
*
*/
String last = names[names.length-1];
int index = -1;
if(last == null){
//没有满
for (int i = 0; i < names.length; i++) {
if(names[i] == null){
index = i;
break;
}
}
}else{
//满了
names = Arrays.copyOf(names, names.length+1);
index = names.length-1;
}
names[index] = name;
return names;
}
/*
* 判断数组中是否有输入的姓名
* 开始,结束,找谁,要返回值
*/
public int searchName(String[] names,String name,int s,int e){
//判断输入的参数是否符合条件
/*
* 开始和结束必须大于0,同时都必须要小于数组长度
* s<e
*/
int flag = 0;
if(s >= 0 && e > 0 && s < e && e <= names.length-1){
//进行查找
for (int i = s; i <= e; i++) {
if(names[i].equals(name)){
//equals用于字符串和对象的比较,比较2个是不是相同,如果相同返回true,不同返回false
flag = 1;
break;
}
}
}else{
System.out.println("输入区间不合理");
}
return flag;
}
}
package com.sky.oop2;
public class Computer {
//实现简易计算器
/*
* 分别实现两个整数,三个浮点数的加法运算
* 创建一个类:computer
* 声明两个方法,1个接受2个整数类型参数
* 1个接受3个小数类型的参数
* 实现他们相加的功能,返回结果
*
*/
public int sum(int a,int b){
return a+b;
}
public double sum(double a,double b,double c){
return a+b+c;
}
}
package com.sky.oop2;
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
/*
Student s = new Student();
s.name = "小美 ";
s.age = 26;
s.address = "东莞市";
s.show();
//一般调用有返回值的方法会定义一个变量来接收结果
String str = s.buySmoke(50);
System.out.println(str);
Computer cpt = new Computer();
System.out.println(cpt.sum(1, 2));
System.out.println(cpt.sum(1.1, 2.2, 3.3));
*/
Student s = new Student();
String[] names = {"xiaomei","xiaoli","xiaojun","xiaofang"};
// String[] names1 = new String[10];
// names1[0] = "xiaolen";
// names = s.add("xiaowen1", names);
// System.out.println(Arrays.toString(names));
// System.out.println(Arrays.toString(s.add("xiaowen", names1)));
String name = "xiaoli";
int i = s.searchName(names, name, 0, 2);
if(i==1){
System.out.println("在数组:"+Arrays.toString(names)+"中找到了:"+name);
}else{
System.out.println("没有找到");
}
}
}
package com.sky.oop3;
public class Computer {
//方法重载:
/*
* 在同一个类中存在多个方法,方法名相同,参数列表不同(参数个数不同,参数类型不同,顺序不同)
* 判断方法是否构成重载
*/
// public int sum(int num1,String num2){
// return 1;
// }
// public int sum(String num1,int num2){
// return 2;
// }
public int sum(int num1,int num2){
return num1+num2;
}
public double sum(double num1,double num2,double num3){
return num1+num2+num3;
}
}
package com.sky.oop3;
public class Dog {
// 成员变量和属性是有默认值的
String name;
String sex;
int health;
int lovely;
/*
* 如果在类中没有显示的编写构造方法的话,系统会帮你添加一个无参的构造方法
* 如果类中存在显示的构造方法了,则系统不会添加
*/
public Dog(){
System.out.println("Dog()");
}
public Dog(String name, String sex){
this.name = name;
this.sex = sex;
System.out.println("Dog(String name, String sex)");
}
public Dog(String name, String sex, int health, int lovely) {
//super();
//this 表示当前对象
/*this 主要功能:
* 1.调用属性,如有参构造中对属性赋值
* 2.调用方法,this.方法名
* 3.调用构造方法 this() - 调用无参构造方法
* 调用构造方法时必须要位于第一行
*/
//this(name,sex);
this.name = name;
this.sex = sex;
this.health = health;
this.lovely = lovely;
//System.out.println("Dog(String name, String sex, int health, int lovely)");
}
public void show(){
System.out.println("我叫"+name+",性别是"+sex+",我的健康值是"+health+",我的活跃度是"+lovely);
}
/*
* 基本数据类型作为参数时,传递的是具体的值
* 对象作为参数在传递的时候,传递的是地址
*/
}
package com.sky.oop3;
public class Demo {
public static void main(String[] args) {
//构造方法:创建对象并且初始化(属性赋值过程)
Dog dog = new Dog();
dog.name = "旺财";
dog.sex = "雌";
dog.health = 90;
dog.lovely = 80;
Dog d = new Dog("来福","雄",80,100);
Computer cpt = new Computer();
System.out.println(cpt.sum(1, 2));
System.out.println(cpt.sum(1.1, 2.2, 3.3));
}
}
package duoduo;
public class Student {
/*
* static 静态
* 可以用来修饰属性,修饰方法,修饰代码块
* static{
*
* }
* 被static修饰的变量 -静态变量
* 被static修饰的方法 -静态方法
* 被static修饰的代码块 -静态代码块
* 静态资源不需要依赖于对象,通过类名.静态资源可以直接访问
* 静态资源(变量和方法)在内存中只有一个,不同的对象操作的都是同一个内容
*
* 注意:在类加载时,先加载静态资源,然后再加载非静态资源
* 在静态方法中能否调用非静态方法?
* 可以创建对象调用非静态方法,但是不能直接调用非静态方法
*
* 可以根据是不是被static修饰的属性,分为静态变量(不依赖对象,直接使用类名来调用),实例变量(必须要对象才能调用的)
*
*/
private String name;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
package duoduo;
public class Computer {
//属性--成员变量
int num;
String brand;
/*
* 1.定义位置不同:成员变量在类中定义,局部变量在方法中定义
* 2.作用域不同:成员变量属于类,在所有方法中都可以使用,局部变量只能在定义的方法中使用
* 3.初始值不同:成员变量有默认值
* 4.优先级不同:如果成员变量和局部变量同名,局部变量的优先级较高
* 5.生命周期不同:成员变量属于类,随着对象的创建而创建,随对象的消失而消失--垃圾回收期;
* 局部变量属于方法,随着方法的调用而创建.
*
*/
//方法,行为,成员方法
public int sum(int num1, int num2){
return num1+num2;
}
public void show(){
System.out.println("品牌:"+brand+",价格:"+num);
}
}
package duoduo;
public class Penguin {
private int health;
private int lovely;
private String name;
private String sex;
public int getHealth() {
return health;
}
public void setHealth(int health) {
if(health < 0 || health > 100){
System.out.println("默认值60");
this.health = 60;
}else{
this.health = health;
}
}
public int getLovely() {
return lovely;
}
public void setLovely(int lovely) {
if(lovely < 0 || lovely > 100){
System.out.println("默认值60");
this.lovely = 60;
}else{
this.lovely = lovely;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Penguin(int health, int lovely, String name, String sex) {
//super();
this.health = health;
this.lovely = lovely;
this.name = name;
this.sex = sex;
}
public Penguin() {
}
public void show(){
System.out.println("姓名:"+name+",性别"+sex+",健康度"+health+",亲密度"+lovely);
}
}
package duoduo;
public class Dog {
//1.所有的属性全部进行私有化
//2.为所有的属性提供getter setter方法
private String name;
private int age;
private int health;
private int lovaly;
//为属性赋值
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
if(age < 0 || age > 30){
System.out.println("赋值不合理,系统给了默认值: 5");
this.age = 5;
}else{
this.age = age;
}
}
public int getAge(){
return age;
}
public void setHealth(int health){
if(health < 0 || health > 100){
System.out.println("赋值不合理,系统给了默认值: 60");
this.health = 60;
}
this.health = health;
}
public int getHealth(){
return health;
}
public void setLovaly(int lovaly){
if(lovaly < 0 || lovaly > 100){
System.out.println("赋值不合理,默认值: 80");
this.lovaly = 80;
}
this.lovaly = lovaly;
}
public int getLovaly(){
return lovaly;
}
}
package duoduo;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
// Computer c = new Computer();
// c.brand = "外星人";
// c.num = 30000;
// c.show();
/*
* 代码是有缺陷的,没有对用户输入的内容做校验
* 不能随意给属性赋值
* 通过封装:
* 1.将属性隐藏起来,在属性前面加上private关键字,隐藏属性,私有化属性
* 2.我们提供操作属性的方法,调用这个方法,也可以实现对这个属性进行赋值
* setHealth(); getHealth();
* 不是不让取值,不能直接取值 了,提供了get方法,这个方法可以将需要的属性给你
* 3.在赋值的时候,对赋值的内容进行审核,如果合理的话,则进行赋值,不合理则给你默认值
*
* 私有化属性,只能在当前类中使用
* 提供公共的getter setter方法,位属性进行赋值取值
* 在setter方法中进行值得审核
*
* 访问权限修饰符
* public 公开的,在任何地方都可以访问
* 默认修饰符 只能在当前包下访问,其他包下的类是不能访问的
* private 私有的,只能在当前类中访问
* protected 访问权限和默认修饰符一样,区别在于它修饰的内容在子类中也可以访问
*
*/
// Dog d = new Dog();
// d.setHealth(-80);
// System.out.println(d.getHealth());
Scanner sc = new Scanner(System.in);
Penguin pe = new Penguin();
System.out.println("欢迎来到宠物店!");
System.out.print("请输入要领养的宠物名字:");
String name = sc.next();
pe.setName(name);
System.out.print("请选择要领养的宠物类型:(1.狗狗 2.企鹅)");
int select1 = sc.nextInt();
String zhonglei = "";
if(select1 == 1){
zhonglei = "狗狗";
}else{
zhonglei = "企鹅";
}
System.out.print("请选择企鹅性别: (1.Q仔 2.Q妹)");
int select2 = sc.nextInt();
String xingbie = "";
if(select2 == 1){
xingbie = "Q仔";
}else{
xingbie = "Q妹";
}
pe.setSex(xingbie);
System.out.print("请输入企鹅健康值:(1~100)");
int health = sc.nextInt();
pe.setHealth(health);
System.out.println("宠物自白:");
System.out.println("我的名字叫"+pe.getName()+",健康值是"+pe.getHealth()+",和主人的亲密度是"+pe.getLovely()+"我的性别是"+pe.getSex());
pe.show();
}
}
package com.sky.oop4;
public class Car {
private int site = 4;
Car(){
System.out.println("载客量"+site+"人");
}
public void setSite(int site){
this.site = site;
}
void print(){
System.out.println("载客量是"+site+"人");
}
}
package com.sky.oop4;
public class Bus extends Car {
Bus(int site){
super();
setSite(site);
}
}
//结果是:输出两句话,载客量4人 载客量是20人
package com.sky.oop4;
//继承
//Pet类 --父类,超类
//Cat类 --子类
//可以调用父类的属性和方法
//在java中只能支持单继承,
public class Cat extends Pet {
public Cat(String name, int age, int health, int lovely) {
// this.name = name;
// this.age = age;
// this.health = health;
// this.lovely = lovely;
super(name,age,health,lovely);
System.out.println("Cat(String name, int age, int health, int lovely)");
}
public Cat() {
super();//调用父类的构造方法,并且必须要第一行
System.out.println("Cat()");
}
}
package com.sky.oop4;
public class Dog extends Pet {
private String sex;
public Dog(String name, int age, String sex, int health, int lovely) {
super(name,age,health,lovely);
// this.name = name;
// this.age = age;
this.sex = sex;
// this.health = health;
// this.lovely = lovely;
System.out.println("Dog(String name, int age, String sex, int health, int lovely)");
}
public Dog() {
System.out.println("Dog()");
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//当子类和父类有相同的方法时,会调用子类的
public void show(){
//子类如何调用父类的方法,使用super关键字(只有被继承的才能被调用)
/*
* super.属性和方法
* super的用法
* 1.调用父类的属性和方法
* 2.还可以调用父类的构造方法,并且必须位于第一行
* 子类在创建对象,调用自己的构造方法的时候,会先调用父类的构造方法
*
* 子类到底继承了父类的哪些东西?
* 1.公共的属性和方法
* 2.被protected修饰的属性和方法
* 3.父类和子类在同一个包下,子类还继承了父类的默认修饰符修饰的内容
*
* 不能继承:
* 1.private修饰的
* 2.不在同一个包下的默认修饰符修饰的内容
* 3.构造方法
*/
super.show();
System.out.println("我的性别是: "+sex);
}
}
package com.sky.oop4;
public class Pet {
private String name;
private int age;
private int health;
private int lovely;
protected int abc;
public Pet() {
System.out.println("Pet()");
}
public Pet(String name, int age, int health, int lovely) {
this.name = name;
this.age = age;
this.health = health;
this.lovely = lovely;
System.out.println("Pet(String name, int age, int health, int lovely)");
}
public void show(){
System.out.println("我叫:"+name+",今年"+age+"岁,健康值是"+health+",活跃度是"+lovely);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLovely() {
return lovely;
}
public void setLovely(int lovely) {
this.lovely = lovely;
}
}
package com.sky.oop4;
public class Demo {
public static void main(String[] args) {
Cat c = new Cat();
c.setName("凯迪");
c.setAge(2);
c.setHealth(80);
c.setLovely(80);
c.show();
Dog d = new Dog();
d.setName("来福");
d.setAge(2);
d.setHealth(90);
d.setLovely(70);
d.setSex("雄");
d.show();
Cat c2 = new Cat("mao2",2,80,40);
Dog d2 = new Dog("gou2",2,"雄",80,80);
c.show();
d.show();
c2.show();
d2.show();
Bus bus = new Bus(20);
bus.print();
}
}
package com.day1021.homework;
public class Voter {
//计数器
static int num = 0;
//属性
private String name;
private int age;
//投票方法
public void vote(){
if(num >= 100){
}else{
num++;
System.out.println(name+"已经投了第"+num+"票");
}
}
public static int getNum() {
return num;
}
public static void setNum(int num) {
Voter.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age < 18 || age > 100){
System.out.println("年龄不符合,默认值18");
this.age = 18;
}else{
this.age = age;
}
}
//构造方法
public Voter() {
}
public Voter(String name, int age) {
//super();
this.name = name;
this.age = age;
}
}
package com.day1021.homework;
public class Demo {
public static void main(String[] args) {
for (int i = 0; i < 200; i++) {
Voter v = new Voter("第"+(i+1)+"人",25);
v.vote();
}
}
}
package com.day1021.homework;
public class StaticTest {
static int num;//0
public static void main(String[] args) {
num++;//1
StaticTest st1 = new StaticTest();
st1.num++;//2
StaticTest st2 = new StaticTest();
st2.num++;//3
StaticTest.num++;//4
System.out.println(num);//4
}
}
package com.day1021.homework;
public class Dog {
private String name = "旺财";
private int health;
private String love;
static int localv;
public void play(int n){
localv = 5;
health = health-n;
System.out.println(name+" "+localv+" "+health+" "+love);
}
public static void main(String[] args){
Dog d = new Dog();
d.play(5);
}
}
package com.sky.oop.practice;
public class Cat extends Pet {
private String color;
public Cat(String name, int age, String sex, String color) {
super(name, age, sex);
this.color = color;
}
public Cat() {
super();
// TODO Auto-generated constructor stub
}
public void show(){
super.show();
System.out.println(",颜色是"+color);
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package com.sky.oop.practice;
public class Dog extends Pet {
private String brand;//种类
public Dog(String name, int age, String sex, String brand) {
super(name, age, sex);
this.brand = brand;
}
public Dog() {
super();
// TODO Auto-generated constructor stub
}
public void show(){
super.show();
System.out.println(",种类是"+brand);
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
}
package com.sky.oop.practice;
public class Pet {
protected String name;
protected int age;
protected String sex;
public void show(){
System.out.println("我叫"+name+",今年"+age+"岁了,性别是"+sex);
}
public Pet(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public Pet() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
package com.sky.oop.practice;
public class Demo {
public static void main(String[] args) {
Dog d = new Dog("旺旺",2,"雄","柯基");
Cat c = new Cat("咪咪",2,"雌","狸花");
d.show();
c.show();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
