- 一、创建类
- 二、创建标准类
- 三、构造类
- 四、局部变量
- 五、封装
- 六、继承
- 七、重写
- 八、重载
- 九、this关键字
- 十、局部变量、成员变量、父类的成员变量
- 十一、异常
一、创建类
1.创建类属性，成员变量（属性）定义在成员方法外
2.创建成员方法 成员方法（行为）
代码如下（示例）：
public class Student {
//定义无返回值的
//成员变量
String name;
int age;
//成员方法
public void study() {
System.out.println("学习");
}
public void sleep() {
System.out.println("睡觉");
}
}
通常情况下一个类能不能直接使用，需要根据一个类创建一个对象，才能使用，因此我们需要创建一个对象来调用这个类。
创建类的步骤
1）导包：
格式：import包名称.类名称;
对于同一个包的情况下，可以省略导包语句
2）创建：
格式：
类名称 对象名=new 类名称（）;
3）使用：
（1）成员属性：
格式： 对象名.成员变量名；、
（2）成员方法：
格式: 对象名.成员方法名（参数）;
代码如下（示例）：
public class Text {
public static void main(String[] args) {
//（1）导包
//（2）创建
//类名称 对象名=new 类名称（）;
//(根据Student类创建一个名为s的对象)
Student s=new Student();
//（3）使用
// 格式： 对象名.成员变量名；
s.name="李华";
s.age=20;
System.out.println(s.name);
System.out.println(s.age);
//对象名.成员方法名（参数）;
s.study();
s.sleep();
}
}
二、创建标准类
定义一个标准类（包括如下四个部分）
（1） 所有的成员变量都用private修饰、
（2） 每个成员变量都有getxxx()detxxx()方法
（3） 有一个无参构造
（4） 有一个全参构造
代码如下（示例）：
public class demo03 {
private String name;
private int age;
public demo03() {
super();
}
public demo03(String name, int age) {
this.name = name;
this.age = age;
}
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 class Text {
public static void main(String[] args) {
demo03 d=new demo03();
d.setName("李华");
d.setAge(16);
System.out.println("我的名字是"+d.getName()+",我的年齡是"+d.getAge());
}
}
三、构造类
格式：public 类名称（形参 实参）{
方法体
}
代码如下（示例）：
public class Dog {
//普通构造
public void Dog() {
System.out.println("我叫哈士奇");
}
//无参构造
public Dog() {
}
//有参构造
public Dog(int age) {
}
}
//测试类
public class Text {
public static void main(String[] args) {
//普通构造调用
Dog dog=new Dog();
dog.Dog();
//无参调用
Dog dog=new Dog();
//有参调用
Dog dog=new Dog(5);
}
}
四、局部变量
代码如下（示例）：
//局部变量定义的两种格式
public class Demo02 {
//第一种定义（不推荐）
public void a() {
String name="哈士奇";
System.out.println(name);
}
//第二种定义（推荐）
public void b(String name) {
System.out.println(name);
}
}
五、封装
一旦使用了private进行修饰，本类当中可以随意访问，但是超出了本类就不可以访问了。
间接访问private成员变量，就定义一对gerxxx（）setxxx（）方法
对于set来说，不能有返回值，参数类型和成员变量对应
对于get来说，不能有参数，必须有返回值类型，并且返回值类型与成员变量对应。
代码如下（示例）：
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//这个成员方法 专门用来向age设置数据
public void setAge(int num) {
this.age = age;
if(num<0||num>100) {
System.out.println("您的输入有误，请重新输入！");
}else{
age=num;
}
}
//这个成员方法 专门用来向age接收数据
public int getAge() {
return age;
}
public void introduce() {
System.out.println("我叫"+name+"，我的年龄是"+age+"岁");
}
}
//测试类
public class Text {
public static void main(String[] args) {
Student s=new Student();
s.setName("李华");
s.setAge(101);
s.introduce();
}
}
六、继承
代码如下（示例）：
//父类
public class Fu {
int age = 20;
public void methodFu() {
System.out.println(age);//输出的ag是本父类的age，不会向下找子类的
}
}
}
//子类
public class Zi extends Fu {
int age = 30;
public void methodZi() {
System.out.println(age);//输出的ag是本子类的age
}
}
//测试类
public class Text {
public static void main(String[] args) {
//创建一个父类对象
Fu fu=new Fu();
System.out.println(fu.age);//只能使用父类的东西
//创建一个子类对象
Zi zi=new Zi();
System.out.println(zi.age);//只有子类的30
System.out.println("=======================");
//1.直接通过子类对象访问成员变量
System.out.println(zi.age);//优秀用子类30
//System.out.println(abc);//子类和父类到处都没有，就编译报错
System.out.println("=======================");
//2.间接通过成员方法名访问成员变量
//2.1这个方法是子类的，优先使用子类的，没有在向上找
zi.methodZi();//30
//2.2这个方法是父类的，
zi.methodFu();;//20
}
}
七、重写
代码如下（示例）：
//新手机类
public class newPhone extends OldPhone{
@Override
public void show() {
super.show();//把父类的show方法拿过来重复利用
//自己子类再来添加更多内容
System.out.println("显示号码");
System.out.println("显示姓名");
}
}
//老手机类
public class OldPhone {
public void call(){
System.out.println("打电话");
}
public void Send(){
System.out.println("发信息");
}
public void show(){
System.out.println("来电提醒");
}
}
//测试类
public class Text {
public static void main(String[] args) {
OldPhone oldphone=new OldPhone();
oldphone.call();
oldphone.Send();
oldphone.show();
System.out.println("============");
newPhone newphone=new newPhone();
newphone.call();
newphone.Send();
newphone.show();
}
}
八、重载
代码如下（示例）：
//重载
public class chongzai {
//标准的方法重载
public void a(int a) {
}
public void a() {
}
//和返回值无关
public int a() {
}
public void a() {
}
//和修饰符无关
public void a() {
}
private void a() {
}
}
//person类
//1.创建类
public class person {
//2.创建类属性 成员变量（属性）定义在成员方法外
String name;
int age;
//3.创建成员方法 成员方法（行为）
//(1)定义有返回值的方法，必须在return返回
public int add() {
return 1;//
}
//(1)定义无返回值的方法
public void add2() {
}
//add3(int count)中的count值为形参
//形参：就是无具体的值
public void add3(int count) {
System.out.println(count);
}
}
//测试类
public class text {
public static void main(String[] args) {
//创建对象的步骤
//1.new person();对象
//2.将对象赋一个名叫hashiqi的变量
//3.变量类型为person
//格式：类名称 变量名=nwe 类名称（）;
//根据Person类创建了一个名为hashiqi的对象
person hashiqi=new person();//调用有返回值的方法的方式如下：
//1.调用haishiqi对象的add()方法，赋值给变量a；
int a=hashiqi.add();
//2.输出变量a的值
System.out.println(a);
hashiqi.add2();//调用无返回值的方法的方式
//add3(5)中的5是实参
//实参：有具体的值
hashiqi.add3(5);//5先调用add3这个方法，然后将参数传到这个方法中，输出的值就变成了5
}
}
九、this关键字
当方法的局部变量和类的成员变量名字相同的时候，根据就近原则优先使用局部变量
如果需要访问本类中的成员变量，需要使用的格式是：this.成员变量名
//通过谁调用的方法就this.谁
//只能在构造方法中通过this调用其他的构造方法，不能在成员方法中使用
//this只能写在构造方法中的第一行
//在同一个构造方法中this只能出现一次，不能在同一个方法中相互调用
代码如下（示例）：
public class demo01 {
String name;
//局部变量：对方的名字
//成员变量：自己的名字
public void sayhellow(String name) {
System.out.println(name+"你好"+",我是"+this.name);
}
}
//测试类
public class Text {
public static void main(String[] args) {
demo01 d=new demo01();
d.name="哈士奇";
d.sayhellow("萨摩");
}
}
十、局部变量、成员变量、父类的成员变量
（1） 局部变量： 直接写变量名
（2）成员变量： this.变量名
（3）父类的成员变量： super.变量名
代码如下（示例）：
//父类
public class Fu {
String name="王某林";
public void Fu() {
System.out.println(name);
}
}
//子类
public class Zi extends Fu {
String name="王某聪";
public void Zi() {
String name="王某孙";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
//测试类
public class Text {
public static void main(String[] args) {
Zi zi=new Zi();
zi.Zi();
}
}
十一、异常
（1） 局部变量： 直接写变量名
（2）成员变量： this.变量名
（3）父类的成员变量： super.变量名
代码如下（示例）：
//Demo01
import java.util.InputMismatchException;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//快捷键 ale+shift+z
try {
Scanner sc=new Scanner(System.in);
int num1;
System.out.println("请输入被除数：");
int n1=sc.nextInt();
int num2;
System.out.println("请输入除数：");
int n2=sc.nextInt();
System.out.println("num1/num2"+"="+n1/n2);
//catch（）方法中的异常代表捕获异常
}
catch (ArithmeticException e) {
//处理异常的一个解决方式
System.out.println("报错啦，请不要让余数为0!!!");
e.printStackTrace();
}catch (InputMismatchException e) {
System.out.println("报错啦,输入的类型不匹配!!!");
e.printStackTrace();
}catch (Exception e) {
System.out.println("最大的异常类型");
e.printStackTrace();
}finally {
System.out.println("程序执行结束，感谢使用!");
}
}
}
//Demo02
public class Demo02 {
public static void main(String[] args) throws Exception {//声明异常
int a=2;
int b=3;
if(a>b) {
throw new Exception("有异常!!!");
}
}
}
