目录
一.类与对象的基本概念
二.类的定义形式与对象的创建语法
1.类的定义形式
2.对象的创建语法
3.具体实例
三.构造方法
四.类的继承
一.类与对象的基本概念
Java是一门向对象的语言(Object Oriented Program，简称OOP)，在Java中，一切皆对象。通过对对象的设计，调用，来完成要求，解决问题，所以在Java中，一切的工作都是围绕创建对象，使用对象来进行。
类：把具有相同属性和行为的一类对象抽象为类。类是抽象出来的一种特征与方法的集合，不具体代表某个特定的东西。
对象：对类实例化操作后，产生的具体实体，此时，类中的属性与方法有了实际的意义。我们通过操作对象，来实现我们在类中定义的方法，达到我们所设计的目的。
二.类的定义形式与对象的创建语法
1.类的定义形式
public class 类名 {
静态变量/类属性；对象属性；
对象方法；
}
静态变量： 用static修饰的属性，所有该类的对象均可共享此属性，可通过类名直接访问。
对象属性： 由类创建对象时，由于对象的特性赋予不同的对象属性，可通过对象名进行访问。
对象方法： 创建的对象所进行具体的操作，可通过对象名进行调用。
权限修饰符：通过对定义的属性，方法进行修饰，来指明该属性和方法可调用或访问的权限范围。
1.private：private修饰的属性和方法，只在该类可见，其他类均不可见。
2.无：缺省修饰符（什么都不写），可被在同一个包中的类访问和调用，不同包中不可见。
3.protected：protected修饰的属性和方法，可在同一个包中的类，不同包中继承此类的子类访问和调用。
4.public：其他类均可调用。
2.对象的创建语法
类名 对象名 = new 类名( )；
3.具体的实例
public class Hero {
//对象属性
private String name;
private int blood;
//对象方法
//设置英雄名
public void setName(String n){
name = n;
}
//get方法，获取名字属性
public String getName(){
return name;
}
//设置血量
public void setblood(int s){
blood = s;
}
//获得当前血量
public int getblood(){
return blood;
}
public static int GetRandomNum(int num1, int num2)
{
int result = (int) (num1 + Math.random() * (num2 - num1 + 1));
return result;
}
//英雄攻击行为
public void pk(Hero b){
int num = GetRandomNum(100,1000);
b.setblood(blood - num);
System.out.println(getName()+"正在攻击"+b.getName()+"掉血"+num+"，现在的血量是"+b.getblood());
}
}
import java.util.Scanner;
public class Manage {
public static void main(String[] args){
//输入英雄名
System.out.println("请输入英雄1的名字：");
Scanner sc = new Scanner(System.in);
Hero hero1 = new Hero();
String input1 = sc.next();
hero1.setName(input1);
//输入英雄血量
System.out.println("请输入英雄的血量：");
int input2 = sc.nextInt();
hero1.setblood(input2);
System.out.println("请输入英雄2的名字：");
String input3 = sc.next();
Hero hero2 = new Hero();
hero2.setName(input3);
System.out.println("请输入英雄的血量：");
int input4 = sc.nextInt();
hero2.setblood(input4);
//判断是否有英雄阵亡
while((hero1.getblood()>0) && (hero2.getblood()>0)) {
hero1.pk(hero2);
hero2.pk(hero1);}
//血量还为正值的英雄胜利
if(hero1.getblood()<0){
System.out.println(hero2.getName()+"胜利");}
else{
System.out.println(hero1.getName()+"胜利");
}
}
}输出结果：
注意：
1.Java中一个源文件只能有一个主类。
2.类命名方法为大驼峰命名法，每个单词首字母要大写。
三.构造方法
构造方法是为了对对象属性进行命名的，定义在类中的一种方法，在new 类名（）的括号中填写赋值内容的方法。
我们先来看平常给对象属性进行赋值的set方法：
//set方法，设置姓名
public void setName(String n){
name = n;
}赋值时，不仅先要创建对象，而且还得调用set方法。而构造方法可一步到位，即创建和赋值用一条语句即可完成。
语法规则：
类名（变量1,变量2,.....）{
this.变量1 = 变量1；
this.变量2 = 变量2；
......
}
1.构造方法无返回值声明。
2.一个类中要有至少一个构造方法，若无定义构造方法，则会生成一个默认的无参构造方法。若定义了构造方法，则默认的无参构造方法不再生成。
public class Student {
private String name;
private int score;
//构造方法
public Student(String name,int score){
this.name = name;
this.score = score;
}
}
//创建对象并赋值
Student st = new Student(Kevin,100);this的思想：调用当前对象的对象属性。
3.构造方法的重载：根据给定的不同个数的变量，调用不同的构造方法。
规则：方法名重名，参数类型（个数，顺序）不同。
public Student(String name,int score){
this.name = name;
this.score = score;
}
public Student(String name){
this.name = name;
}
public Student(){
System.out.println("Student...");
}4.构造方法间的相互调用
语法规则：
this(变量1,变量2,..)；
注意：相互调用时，必须将该语句放至构造方法的第一行。
public Student(String name,int score){
this.name = name;
this.score = score;
}
public Student(){
this("kevin",100);
System.out.println("Student...");
}四.类的继承
类的继承可以理解为一种包含关系，父类包含的范围更大，更笼统，而我们需要在父类的基础上去细化，具体化我们的需求类，就需要类的继承，并在父类的基础上重写方法来满足不同子类的特点。
语法规则：
public class 子类 extends 父类 implements 接口1，接口2，.....{ }
1.对类的继承用extends，对接口的继承用implements。
2.Java中对类只允许单继承，但是接口可多继承，允许多重继承。
3.（同包下）子类会继承父类中所有的属性和方法，但是私有属性和方法不能直接使用，可通过公有方法调用。
4.Java中创建类时，会默认继承Object类，即Java中所有类都是Object类的子类。Object 类位于 java.lang 包中，编译时会自动导入， 当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。
5.子类一定会调用父类中的构造方法，若父类中有无参构造方法，则子类中会默认调用，不用在子类中再写；若父类有有参构造方法，子类中也必须写，并用super（变量1，变量2，...）写在代码第一行。
//父类
public class Student {
private String name;
private int score;
//构造方法
public Student(String name,int score){
this.name = name;
this.score = score;
}
}
//子类
public class UNStudent extends Student {
public UNStudent(){
super("",1);
System.out.println("UNStudent...");
}6.方法重写
规则：
1.有继承关系的两个类之间。
2.（访问修饰符权限大于等于父类）返回值类型，方法名，参数（个数，顺序）完全一样。
3.可通过super.方法名保留父类方法。
//父类方法
void study(){
System.out.println(name+"正在学习！");
}
//子类方法
public void study(){
super.study();
System.out.println("子类重写父类的方法！");
}7.自动转型/强制转型
数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型成另一种数据类型以满足要求。其中，这两种数据类型要相容，且目标类型范围大于源数据类型。
自动转型：A为B的父类，将B转为A，此时转型自动发生。
A a = new B( );
实例;
//此方法需要的类型为Component
public Component add(Component comp) {
addImpl(comp, null, -1);
return comp;
}
//JButton类可输入
JButton jbu1 = new JButton("直线");
jf.add(jbu1);
//JLabel类可输入
JLabel user = new JLabel("画笔颜色:");
jf.add(user);
//看源码可知,JLabel的父类为Component,此时发生了自动转型
public class JLabel extends JComponent implements SwingConstants, Accessible{...}
public abstract class JComponent extends Container implements Serializable,
TransferHandler.HasGetTransferHandler
{...}
public class Container extends Component {...}强制转型：将父类转换成子类。
子类名 子类对象名 = （子类名）父类对象名；
实例：
//子类UNSudent,父类Student
UNStudent unst = (UNStudent)st;
unst.printName();
2188
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
