封装:
封装步骤:
1.使用private修饰需要被封装的属性。
2.提供一个公共的方法设置或获取该私有成员属性。(set属性名(),get属性名())
代码:
class Member
{
String name;
private String sex;
String salary;
public void talk(){
System.out.println(name + "happy day");
}
public void setSex(String ss)
{
if(ss.equals("男")||ss.equals("女"))
sex = ss;
else
sex = "男";
}
public String getSex( )
{
return sex;
}
}
class demo1
{
public static void main(String[] args){
Member m = new Member();
m.setSex("dd");
System.out.println("性别:" + m.getSex());
}
}
**************************************************
class Calc
{
private int num1;
private int num2;
private char ch;
public void setNum1(int a){
num1=a;
}
public void setNum2(int b){
num2=b;
}
public void setCh(char st){
ch=st;
}
public int run(){
if(ch=='+')
return num1 + num2;
else if(ch== '-')
return num1 - num2;
else if(ch== '*')
return num1 * num2;
else
return num1 / num2;
}
}
class demo1
{
public static void main(String[] args ){
Calc dd = new Calc();
dd.setNum1(1);
dd.setNum2(2);
dd.setCh('-');
System.out.println( dd.run() );
}
}
继承:
格式:
class 类名1 extends class 类名2
{
}
使用注意:
** 只有存在继承关系的时候才去继承。
** 父类私有的成员和构造函数不能被继承。
** 创建子类时java编译器会默认调用父类的无参的构造方法。
(调用父类的构造方法可以初始化从父类继承下去的属性)
代码:
class Person
{
String name;
public Person(String name)
{
this.name = name;
System.out.println("Person 有 参数的构造方法调用了");
}
public Person()
{
System.out.println("Person 无 参数的构造方法调用了");
}
public void eat()
{
System.out.println("Person eat eat");
}
}
class Student extends Person
{
int num;
public Student(String name)
{
super(name); //指定调用父类一个参数的构造函数。。。
//this.name = name;
System.out.println("Student 有 参数的构造方法调用了");
}
public void study()
{
System.out.println("Student study study");
}
}
class Demo3
{
public static void main(String[] args)
{
Student s = new Student("ddddd");
s.eat();
System.out.println("Hello World!" + s.name);
}
}
方法的重写:(子父类出现同名函数)
前提:
1.必须要存在继承关系。
注意事项:
1. 方法名和形参列表必须一致;
2. 子类的权限修饰符 > = 父类的权限修饰符
3. 子类的返回值类型 < = 父类的返回值类型
4. 子类抛出的异常类型 < = 父类抛出的异常类型
Exception (最坏)
RuntimeException ( 小坏)
代码:
class Fu
{
String name;
public Fu(String name)
{
this.name = name;
}
public void eat(){
System.out.println(name + "吃番薯。。。。。");
}
}
class Zi extends Fu
{
String num;
public Zi(String name)
{
super(name);
}
public void eat()
{
System.out.println("ffffffff");
}
}
class Demo1
{
public static void main(String[] args)
{
Zi z = new Zi("大头儿子");
z.eat();
System.out.println("Hello World!");
}
}
多态
定义:
一个类有有多种形态。(例如:动物可以由多种组成)
两种表现:1.父类的引用类型变量指向了接口实现类的对象;
2.接口的引用类型变量指向了接口实现类的对象。
使用前提:
必须存在继承和实现关系。
使用注意:
1.多态情况下,子父类存在同名的成员时,默认访问父类的成员,除了在同名的非静态函数时,访问的是子类函数。
2.多态情况下,不能访问子类特有的成员。
多态的应用:
1.多态用于形式参数类型时,可以接收更多类型的数据。
2.多态用于返回值类型时,可以返回更多类型的数据。
样例代码:
abstract class MyShape
{
public abstract void getArea();
public abstract void getLength();
}
class Rect extends MyShape
{
double x,y;
public Rect(double x,double y)
{
this.x =x;
this.y =y;
}
public void getArea()
{
System.out.println("矩形的面积" + x*y);
}
public void getLength()
{
System.out.println("矩形的周长" + 2*(x+y));
}
}
class Circle extends MyShape
{
public static final double PI = 3.14;
double r;
public Circle(double r)
{
this.r = r ;
}
public void getArea()
{
System.out.println("圆的面积" + PI*r*r);
}
public void getLength()
{
System.out.println("圆的周长" + 2*PI*r);
}
}
class Demo3
{
public static void main(String[] args)
{
MyShape a = new Circle(4.0); // 多态的使用
print(a);
Myshape b = new Rect(4,5);
print(b);
}
public static void print(MyShape s)
{
s.getArea();
s.getLength();
}
}
***************************************************
// 多态在接口中的使用:
interface Dao
{
public abstract void print();
public abstract void eat();
}
class UerDao implements Dao
{
public void print()
{
System.out.println("走走走");
}
public void eat()
{
System.out.println("吃吃吃");
}
}
class Demo9
{
public static void main(String[] args)
{
Dao a = new UerDao();
a.print();
a.eat();
}
}